  - 

( )
--------------------------------------------------------
䥤 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);







