  - 
( )
--------------------------------------------------------
䥤 22




᭨⥫쭠 ᪠ 

 

 ⥬
"ࠡ⪠ ᪮ 
 몠 ணࠬ஢ ଠ"


㤥⪨ 㯯 7-01

񭪨 죨 ᠭ஢




 㪮⥫:


:



業:


᪢ 1995.



 1. 
	 ᮮ⢥⢨         ᥬ ।  뫨 ⠢ ᫥騥 楫:
	-   몮 ணࠬ஢ ଠ   ;
	-   ࠭  몠 ணࠬ஢ ଠ;
	-   ⮤ ᪮ ;
	-   ᪮ ;
	- ࠧࠡ    ॠ樨 ᪮ ;
	-  㭪,  室 ன 㯠 ᯨ᮪ ᥬ,   室 - ᯨ᮪ ᯨ᪮. ⮬ ⮣ ᯨ᪠ ᯨ᪮  ᯨ᮪ ᥬ,  ।⠢ ᮡ  । ணࠬ, ᠭ  ଥ, 稢饥 窮. ..  㭪 "०" 㯠騩  室 ᯨ᮪ ᥬ  窠.



2.  ࠪ⨪ 몠 ଠ
	2.1  ணࠬ஢ ଠ.
	 ணࠬ஢ ଠ  ⨢ (楤) 몮  ।祭  ᯥ䨪樨  ᫨⥫쭮 ࠪ.   ࠭樨,  ࠤ樮 , ਬ, ᨭ⠪᪮, ᥬ᪮ , 蠥  ᨭ⥧ 室 ணࠬ,   । 浪 ᫥  ᯮᮡ ᫥  ⮬ ⥩ 室 몠  ⥪ .
	 ଠ  ᯥ樫஢ 몮  ।祭  ᯥ䨪樨 ᫥ ⮤ 襭  ⥬᪮ 䨧. 砫쭮   ਥ஢  襭  ⥬᪮ 䨧 ࠧ묨 ⮤,    ᯮ짮  襭  ப  ᫨⥫ .
	  襭    ⥬᪮ 䨧 ⮨  ᫥ ⠯.
	1. ⠭ . 室 ⮣ ⠯  筮 ⥬ ७樠 ࠢ, 뢠 .
	2. 롮 ࠭⢥-६ ⪨  ⨧ ࠢ     ࠧ ⮤.
	3. 롮 ⮤ 襭  ࠢ.  १   (ᮮ⭮襭), 뢠騩 室 ᫥  㧫 ⪨.
	4. ணࠬ஢ 祭   ஬ 몥,  ᯥ稢 襭   ᫨⥫쭮 設.
	 ,   ᭮ 몠 ଠ, 砥  ⮬,  祭 ਪ ᯥ樠⮬   襭 ਪ     ।⢥ ᯮ    ᫨⥫ ⥬  ஢ .
	 ࠧ,  ଠ  ਪ ⥬⨪  㫨஢ ᢮   ਢ   ନ. ࣠  ᫥  ⮬ ⥪  (⥩ ࠫ쭮, ୮ ࠡ⪨  . .) -   ࠭  몠 ଠ.
	⢥ 䠪⮬   ॠ樨  ணࠬ  몥 ଠ ࠧ묨 ᫨⥫묨 ᠬ.  ࠧࠡ⪠ ⬠  ࠪ⨪,   ⨬  䥪⨢ 뢠騬 ᮡ  ,   㧪 ⮬ ᮧ ᮪⢥ ணࠬ ᯥ祭.
	  몥 ଠ - ,  , ண  ᫥ ⮤ 襭 ⥬᪮ ,    ⬮,      ⠫쭮 室 ଠ樨,  室 , ⮡  ணࠬ  .
	⬥⨬,     ଥ  ॡ  ଠ樨  浪 , ᯮᮡ ࣠樨 ᫨⥫ (横᪨) ᮢ. 冷 । 몠   ந - ଠ樮 裡    ⥭  ࣠樨   ࠭஬.
	롮 ஢ 몠 ଠ । ࠪ   -  ⮬ 몥  室  ⠪ ,   ᢠ   ९ᢠ 祭 (⨯ :=+1)   室. 稥 ⠪ ⨩  ࠤ樮 몠 ணࠬ஢  室 㫨஢ ⭮ ⬠  ⮬ ᮢ   । , 浪 믮 ஢  . .  䥪  몥 ଠ   ।.
	⭮,     ᮢ  ᭮  ⠯ ᨭ⥧ ࠡ祩 ணࠬ. ,    ⮬᪨  ண ࢨ, ࠭騬 ࠢ쭮 ᨭ⥧㥬 ணࠬ.
	楤୮ 몠 ଠ  ८   㤭, 易  ᯠࠫ ⬠    , ᪠ ᮢ饭 権.  ⮤ ᯠࠫ ᫥⥫ ⬮ ᭮  ,   ࠭祭, ⥩ ⬠,   믮 ᨬ,  ᮮ⢥⢨   ਥ ࠫ - ᨭ஭ ᫥, ᨭ஭  . . ,  痢  㦥 ନ஢ ᫥⥫쭮 ⬥  ⢥  㤭 祩, ⠪  㥬 㫨஢,  ࠢ, 饭 묨 ﬨ (⨯  ࠡ ६   ,  ᯮᮡ ࣠樨 横  . .).  ,  㤠  ᫥,  ᫥⥫   ࠭᫨஢  ࠫ,   । ࠫ ࠧ  楤୮ .
	 ᢮⢠,   㣨 ࠭祭,  ண ᭮ ࠧ訬 ᨭ⥧ 室 ணࠬ, ⠪   筮 饩 ⠭ 襭 ⮩  ਢ  ⥫ ⥬᪨ 㤭 -    NP-   ࠧ訬.  㣮 ஭, ᫥, 易  ࠧࠡ⪮  ਬ 몠 ଠ 뢠,  騥 ࠭祭 ਥ  ࠪ᪮ 窨 ७.
	室 ணࠬ, ᠭ  몥 ணࠬ஢ ଠ, ।⠢  室 䠩  ᫥騬 ࠢ:
	- ⥪   ࠧ ଠ-ணࠬ 뢠  ଥ ।⠢.  ७ ᠭ    ᫥ ப 頥 ࠧ뢠 祢 ᫮, 䨪, ⠭,  ⠫쭮 ࠢ ७ ந.
	- 祢 ᫮, 䨪, ⠭, ⤥   㣠 ஡, ᯥ樠묨 ᨬ, ᨬ  ப. ஡  騬 ᨬ: 㯯 ஡ ࠪ   ஡.
	- ப, 稭   "!",  ਥ. ਨ  ᠭ   ࠧ 饭.
	- ਨ  ᯮ짮   ASSUME  ᫥ :    ASSUME  ⥫ ;  ᮮ⭮襭ﬨ  ⥫ .
	- ਨ  ᯮ짮  樨 ITERATION  ᫥ :   BOUNDARY...END BOUNDARY; 
  INITIAL...END INITIAL;
 ⥫ 樨. 
	- ⥪ ணࠬ ।祭  ࠭樨, 稢 ப : ଠ, ᫥  ࠭஬  ࠡ뢠.
	- ଠ, ᯮ  ࢠ  "?", 饣  ࢮ 樨,   "?", 饣 ⠪  ࢮ 樨, ࠭஬  ࠡ뢠.    롨  室 䠩  ࠧ,  室 ࠭᫨஢.            .
	2.2  ࠭  몠 ଠ.
	࠭  몠 ணࠬ஢ ଠ 㦥 ᠭ  몥 䠫.  뫮 襭 ॢ ࠭  몠 ணࠬ஢ ଠ   ணࠬ஢ .  ணࠬ஢   ࠭  ᫥騬 稭:
	- । ᮢ६ 몮 ணࠬ஢       ࠭;
	-   㭨ᠫ   䥪⨢  ਬ   ⥬ ணࠬ஢ - ࠧࠡ⪥ ࠭஢, 樮 ⥬, ࠭ 䥩ᮢ, 㬥⠫ ।;
	- ࠧࠡ稪 몠 ଠ 㦥 ᠭ 䥩  몥 , 騩 祭  ࠭, ᠭ  䠫,   祭  ࠭, ᠭ  ,  ⫠ ࠭.
	࠭  몠 ணࠬ஢  ᫥ :
.1

⥪ ᪨      ᨭ⠪᪨       . 浪            FORTRAN
                                        .  ᯠ.




                                         ⠡


	
	 室 ᪮  㯠 ⥪ 室 ணࠬ, ᠭ  몥 ணࠬ஢ ଠ.  室 - ஢  ᠭ, ࠬ   ᯨ᮪ ᯨ᪮. ⮬ ⮣ ᯨ᪠ ᯨ᪮  ᯨ᮪ ᥬ,  ।⠢ ᮡ  । ணࠬ, ᠭ  ଥ, 稢饥 窮. 
	  ᯨ᮪ ᯨ᪮ 㯠  室 ᨭ⠪᪮ .  室 ᨭ⠪᪨  뤠 ⠡ ᠭ, ⠡ ஢.
	 ⠡ 㯠  室 ᫥饣 ⠯,  ந室 । 浪 ᫥  ࠧ  ࠫ ⢨ ᫥, 騥   㣠.  室 砥 ७ .
	७  㯠  室 樨. 室 樨  ணࠬ  몥 ࠭.
	   , 騩 ࠡ  .  ⢨  ஬  ந室    ⠯. ⢨  ⠡栬 ⠪ ந室    ⠯.


	2.3 ⢮  ⮤ ᪮ .
	 १ 믮 ⮣   㧭,   ᪮  ਬ  ᯮ ᫥騥 ⮤:
	-  ⮬  -ࠬ⨪, 뢠騥  ⮬;

	2.4  ᪮ .
	 室 ᪮  㯠 ⥪ 室 ணࠬ, ᠭ  몥 ଠ. ணࠬ, ᠭ  몥 ଠ, ࠭᫨  ࠧ. 砫 ࠭᫨  ࠧ, ᫥ ⮣,   㤥 ࠭᫨஢, 筥 ࠭ ᫥饣 ࠧ. 
	 ࢮ 蠣 ந室 ⥭ 室 ⥪ ணࠬ  ଥ  ࠧ   ᥬ. ⮬ ⮣ 蠣  ᯨ᮪ ᥬ.
	 -ࠧ (ᠭ, , ) 稢 窮. ⮬  ᫥饬 蠣 ந室 "१" ᯨ᪠ ᥬ  窠.  १ ⮩ 楤 砥 ᯨ᮪ ᯨ᪮. ⮬ ⮣ ᯨ᪠ ᯨ᪮  ᯨ᮪ ᥬ,  ।⠢ ᮡ  । ணࠬ, ᠭ  ଥ, 稢饥 窮.
	 ᫥饬 蠣 ந室 ஢ ᯨ᪠ ᯨ᪮  ᠭ, ࠬ  .  १ 砥 ᯨ᮪ ᯨ᪮,  ஬ ᭠砫   ᠭ ࠧ, ⥬   ࠧ,   祭,  樨 ࠧ.
	᫥ ⮣ ஢ ᯨ᮪ ᯨ᪮   室 ᨭ⠪᪮ .

	2.5 ࠡ⪠    ॠ樨 ᪮ 
	 ॠ樨 ᪮     ࠡ 뫨 ࠧࠡ⠭ ᫥騥  :
	1) ᯨ᮪ ᥬ ।⠢ ᫥饩 ன:
	struct spis  
		{ int p1,p2;
		struct spis *next;} rec1;
	 1  2 -  ⨯ 楫,    ⠡    ⠡ ᮮ⢥⢥;  ⨬ ࠬ १ ⠡ ⠭  ᮮ⢥⢨ ⭠ ᥬ,   䨪, 祢 ᫮, ⠭,  樨  ࠧ⥫;
	next -  㪠⥫  ᫥騩  ᯨ᪠ ᥬ;
	  ।⠢ ᪨  .2
.2
	


	2) ᯨ᮪ ᯨ᪮ ।⠢ ᫥饩 ன:
	struct spspis
		{int p1,p2;  
		struct spis *next;
		struct spspis *link;} rec2;
	 1  2 -  ⨯ 楫,    ⠡    ⠡ ᮮ⢥⢥; ⨬ ࠬ १ ⠡ ⠭  ᮮ⢥⢨ ⭠ ᥬ,   䨪, 祢 ᫮, ⠭,  樨  ࠧ⥫;
	next -  㪠⥫   ᯨ᮪ ᥬ;
	link -  㪠⥫  ᫥騩  ᯨ᪠ ᯨ᪮.
	⮬ ⮣ ᯨ᪠ ᯨ᪮  ᯨ᮪ ᥬ,  ।⠢ ᮡ  । ணࠬ, ᠭ  ଥ, 稢饥 窮,  ᯨ᮪ ᯨ᪮ ।⠢ ᮡ ᮮ⢥⢥ ᯨ᮪ ।.   ।⠢ ᪨  .3
.3
                                


                                


                             


                             
	
	

	2.6  㭪 "१" ᯨ᪠ ᥬ  窠.
	   ॡ  㭪,  室 ன 㯠 ᯨ᮪ ᥬ,   室 砥 ᯨ᮪ ᯨ᪮. ⮬ ⮣ ᯨ᪠ ᯨ᪮  ᯨ᮪ ᥬ,  ।⠢ ᮡ  । ணࠬ, ᠭ  ଥ, 稢饥 窮. ..  㭪 "०" 㯠騩  室 ᯨ᮪ ᥬ  窠,   室 뤠 ᯨ᮪ ।,    稢 窮  ।⠢ ᯨ᪮ ᥬ.
	 ਢ     奬  ᠬ 㭪.

#include<stdio.h>      /*祭 䠩 stdio.h*/
#include<alloc.h>      /* 祭 䠩 alloc.h */ 
#include<process.h>   /* 祭 䠩 sprocess.h */

struct spis                           /*  ᯨ᪠,   */
	{ int p1,p2;               /*ண    ⨯ 楫, (1-*/
	struct spis *next;} rec1;/*⠡, 2-  ⠡)  -㪠⥫*/
                                       /* ᫥騩  ᯨ᪠*/
struct spspis                        /*   ᯨ᪠ ᯨ᪮,  */
	{int p1,p2;               /* ண    ⨯ 楫,*/
                                      1- ⠡,2-   ⠡*/
	struct spspis *link;    /* 㪠⥫  ᫥騩  ᯨ᪠ ᯨ᪮*/
	struct spis *next;} rec2;/*㪠⥫   ᯨ᮪*/
struct spis *f,*q,*r;              /* 㪠⥫   ᯨ᮪ */
struct spspis *t1,*t;             /* 㪠⥫   ᯨ᮪ ᯨ᪮*/

struct spspis *tochka(p)   /* 㭪樨, 饩 㪠⥫  				     ᯨ᮪ ᯨ᪮*/
struct spis *p;          /*㬥⮬ 㭪樨  㪠⥫  ᯨ᮪*/
{
f=p;    /*ᢠ ࠡ祩 ६ 祭 㬥 㭪樨*/
t=malloc(sizeof( rec2));/*ᮧ 1-  ᯨ᪠ ᯨ᪮*/
t1=t;  /* ᢠ ࠡ祩 ६ 㪠⥫  ᯨ᮪ ᯨ᪮*/
while(f!=NULL) /*⥫   㤥 믮   ,   		    ⮣  ᯨ᪠ ᥬ*/
{	t1->p1=f->p1;/*ᢠ 祭   ᯨ᪠ ᯨ᪮*/
	t1->p2=f->p2;
	f=f->next;
	if (f!=NULL)
	{  t1->next=malloc(sizeof(rec1));/*ᮧ 1-  ᯨ᪠  ᯨ᪥ 						ᯨ᪮*/
	      q=t1->next;/* ᢠ ࠡ祩	 ६ 㪠⥫  				      ᯨ᪠*/
	      do  /*ᮧ ᠬ ᯨ᪠ ᥬ  ᯨ᪥ ᯨ᪮*/
	      {
		q->p1=f->p1;/*ᢠ 祭   ᯨ᪠*/
		q->p2=f->p2;
		if ((q->p1!=1) && (q->p2!=1))/*᫨  ᥬ   						窮*/
		{ q->next=malloc(sizeof(rec1));//* ᮧ   ᯨ᪠ */
		q=q->next;
		}
		else { t1->link=malloc(sizeof(rec2));/*, ᮧ   							ᯨ᪠ ᯨ᪮*/
		    t1=t1->link;
		};
	f=f->next;
	}
	while(((q->p1!=1) && (q->p2!=1)) || (f!=NULL)) ;/*⥫   믮   ,   㤥 ⠭ 窠,   㤥 ⨣  ᯨ᪠ ᥬ,  㪠뢠 㬥 㭪樨*/
	}
}
return(t);/*㭪 頥 㪠⥫  ᯨ᮪ ᯨ᪮*/
}



砫


f:=p
t:=new rec2
t:=t1

                                                      f<>NULL          

          
t1.p1:=f.p1
t1.p2:=f.p2
f:=f.next

                                                                                   
                                                     f<>NULL              

            
t1.next:=new rec1
q:=t1.next


q.p1:=f.p1
q.p2:=f.p2


(q.p1<>1)&(q.p2<>1)

         q.next:=new rec1                                                    t1.link:=new rec2
         q:=q.next                                                                  t1:=t1.link

f:=f.next

((q.p1<>1)&(q.p2<>1))or(f<>NULL)
                                 
                                                    




return(t)



 


	3. 
	 १ த ࠡ  뫨 ⨣ ᫥騥 楫:
	-   稫 楤  ணࠬ஢ ଠ, ।祭   ᫥ ⮤ 襭  ⥬᪮ 䨧 ࠧ묨 ⮤;
	- 稫  ࠭  몠 ணࠬ஢ ଠ;
	-   ⮤ ᪮ ;
	- 稫  ᪮ ;
	- ࠧࠡ⠫   ᢮    ॠ樨 	᪮ ;
	-ᠫ 㭪,  室 ன 㯠 ᯨ᮪ ᥬ,   室 砥 ᯨ᮪ ᯨ᪮. ⮬ ⮣ ᯨ᪠ ᯨ᪮  ᯨ᮪ ᥬ,  ।⠢ ᮡ  । ணࠬ, ᠭ  ଥ, 稢饥 窮. ..  㭪 "०" 㯠騩  室 ᯨ᮪ ᥬ  窠,   室 砥 ᯨ᮪ ।,    稢 窮  ।⠢ ᯨ᪮ ᥬ.
	ணࠬ 室   ⠤ ࠧࠡ⪨.  襭 ࠡ   ᫥饬 ᥬ.       믮 .

᮪ :
	.. ਠ, .. 䨬, .. 堩, ..  " ଠ"
	.. ਠ, .. 䨬, .. 堩 "楤  ଠ  ⮤  ॠ樨"
	.. 㣥 " ⥬᪨ 㭪権 몠 ଠ  । ᫨⥫ ⥬"

ਫ 1.
#include<stdio.h>
#include<alloc.h>
#include<process.h>

struct spis
      { int p1,p2;
	struct spis *next;} rec1;
struct spspis
      {int p1,p2;
       struct spspis *link;
       struct spis *next;} rec2;
struct spis *f,*q,*r;
struct spspis *t1,*t;

extern struct spspis *(tochka(struct spis*));

struct spspis *tochka(p)
struct spis *p;
{
f=p;
t=malloc(sizeof( rec2));
t1=t;
while(f!=NULL)
{  t1->p1=f->p1;
   t1->p2=f->p2;
   f=f->next;
   if (f!=NULL)
   {  t1->next=malloc(sizeof(rec1));
      q=t1->next;
      do
      {q->p1=f->p1;
	q->p2=f->p2;
	if ((q->p1!=1) && (q->p2!=1))
	   { q->next=malloc(sizeof(rec1));
	     q=q->next;   }
	else { t1->link=malloc(sizeof(rec2));
	       t1=t1->link;};
	f=f->next;}
	while(((q->p1!=1) && (q->p2!=1)) || (f!=NULL)) ;
    }
}
  return(t);}
main() {
tochka(r);return(0);
}



