Переделать программу с Паскаля на C++

const COUNT_POINTS=6;
 
type
ARRN=array[1..COUNT_POINTS] of integer;
ARRNN=array[1..COUNT_POINTS,1..COUNT_POINTS] of integer;
 
PROCEDURE FITSP(N,S,INF:INTEGER; VAR W:ARRNN; VAR ROUTE:ARRN; VAR PATH_WEIGHT:INTEGER);
VAR END1,END2,FARTHEST,I,INDEX,
INSCOST,J,MAXDIST,NEWCOST,NEXTINDEX :INTEGER;
CYCLE,DIST :ARRN;
BEGIN
FOR I:=1 TO N DO CYCLE[I]:=0;
CYCLE[S]:=S;
FOR I:=1 TO N DO DIST[I]:=W[S,I];
PATH_WEIGHT:=0;
FOR I:=1 TO N-1 DO
BEGIN
MAXDIST:=-INF;
FOR J:=1 TO N DO
IF CYCLE[J] = 0 THEN
IF DIST[J] > MAXDIST THEN
BEGIN
MAXDIST:=DIST[J]; FARTHEST:=J
END;
INSCOST:=INF; INDEX:=S;
FOR J:=1 TO I DO
BEGIN
NEXTINDEX:=CYCLE[INDEX];
NEWCOST:=W[INDEX,FARTHEST]+W[FARTHEST,NEXTINDEX]-
W[INDEX,NEXTINDEX];
IF NEWCOST < INSCOST THEN
BEGIN
INSCOST:=NEWCOST;
END1:=INDEX; END2:=NEXTINDEX
END;
INDEX:=NEXTINDEX
END; { FOR J }
CYCLE[FARTHEST]:=END2; CYCLE[END1]:=FARTHEST;
PATH_WEIGHT:=PATH_WEIGHT+INSCOST;
FOR J:=1 TO N DO
IF CYCLE[J] = 0 THEN
IF W[FARTHEST,J] < DIST[J] THEN DIST[J]:=W[FARTHEST,J]
END; { FOR I }
INDEX:=S;
FOR I:=1 TO N DO
BEGIN
ROUTE[I]:=INDEX; INDEX:=CYCLE[INDEX]
END
END;
 
 
procedure THREEOPT(N:integer; var W:ARRNN; var ROUTE:ARRN);
 
type SWAPTYPE =(ASYMMETRIC,SYMMETRIC);
SWAPRECORD=record
X1,X2,Y1,Y2,Z1,Z2,GAIN:integer;
CHOICE :SWAPTYPE
end;
var BESTSWAP,SWAP:SWAPRECORD;
I,INDEX,J,K :integer;
PTR :ARRN;
 
procedure SWAPCHECK(var SWAP:SWAPRECORD);
var DELWEIGHT,MAX:integer;
begin
with SWAP do begin
GAIN:=0;
DELWEIGHT:=W[X1,X2]+W[Y1,Y2]+W[Z1,Z2];
MAX:=DELWEIGHT-(W[Y1,X1]+W[Z1,X2]+W[Z2,Y2]);
if MAX > GAIN then begin
GAIN:=MAX; CHOICE:=ASYMMETRIC
end;
MAX:=DELWEIGHT-(W[X1,Y2]+W[Z1,X2]+W[Y1,Z2]);
if MAX > GAIN then begin
GAIN:=MAX; CHOICE :=SYMMETRIC
end
end
end;
 
procedure REVERSE(START,FINISH:integer);
var AHEAD,LAST,NEXT:integer;
begin
if START <> FINISH then begin
LAST:=START; NEXT:=PTR[LAST];
repeat
AHEAD:=PTR[NEXT]; PTR[NEXT]:=LAST;
LAST:=NEXT; NEXT:=AHEAD;
until LAST = FINISH
end { if START <> FINISH }
end; { RESERVE }
 
begin { MAIN BODY }
for I:=1 to N-1 do PTR[ROUTE[I]]:=ROUTE[I+1];
PTR[ROUTE[N]]:=ROUTE[1];
repeat { until BESTSWAP.GAIN = 0 }
BESTSWAP.GAIN:=0;
SWAP.X1:=1;
for I:=1 to N do begin
SWAP.X2:=PTR[SWAP.X1]; SWAP.Y1:=SWAP.X2;
for J:=2 to N-3 do begin
SWAP.Y2:=PTR[SWAP.Y1]; SWAP.Z1:=PTR[SWAP.Y2];
for K:=J+2 to N-1 do begin
SWAP.Z2:=PTR[SWAP.Z1];
SWAPCHECK(SWAP);
if SWAP.GAIN > BESTSWAP.GAIN then BESTSWAP:=SWAP;
SWAP.Z1:=SWAP.Z2
end; { for K }
SWAP.Y1:=SWAP.Y2
end; { for J }
SWAP.X1:=SWAP.X2
end; { for I }
if BESTSWAP.GAIN > 0 then
with BESTSWAP do begin
if CHOICE = ASYMMETRIC then begin
REVERSE(Z2,X1);
PTR[Y1]:=X1; PTR[Z2]:=Y2
end
else begin
PTR[X1]:=Y2; PTR[Y1]:=Z2
end;
PTR[Z1]:=X2;
end { with BESTSWAP }
until BESTSWAP.GAIN = 0;
INDEX:=1;
for I:=1 to N do begin
ROUTE[I]:=INDEX; INDEX:=PTR[INDEX]
end
end;
 
PROCEDURE TWOOPT( N:INTEGER; VAR W:ARRNN; VAR ROUTE:ARRN; VAR PATH_WEIGHT:INTEGER);
 
VAR AHEAD,I,I1,I2,INDEX,J,J1,J2,
LAST,LIMIT,MAX,MAX1,NEXT,S1,S2,T1,T2:INTEGER;
PTR :ARRN;
BEGIN
FOR I:=1 TO N-1 DO PTR[ROUTE[I]]:=ROUTE[I+1];
PTR[ROUTE[N]]:=ROUTE[1];
REPEAT { UNTIL MAX = 0 }
MAX:=0; I1:=1;
FOR I:=1 TO N-2 DO
BEGIN
IF I = 1 THEN LIMIT:=N-1
ELSE LIMIT:=N;
I2:=PTR[I1]; J1:=PTR[I2];
FOR J:=I+2 TO LIMIT DO
BEGIN
J2:=PTR[J1];
MAX1:=W[I1,I2]+W[J1,J2]-(W[I1,J1]+W[I2,J2]);
IF MAX1 > MAX THEN
BEGIN { BETTER PAIR HAS BEEN FOUND }
S1:=I1; S2:=I2;
T1:=J1; T2:=J2;
MAX:=MAX1
END;
J1:=J2
END; { FOR J }
I1:=I2
END; { FOR I }
IF MAX > 0 THEN
BEGIN { SWAP PAIR OF EDGES }
PTR[S1]:=T1;
NEXT:=S2; LAST:=T2;
REPEAT
AHEAD:=PTR[NEXT]; PTR[NEXT]:=LAST;
LAST:=NEXT; NEXT:=AHEAD
UNTIL NEXT = T2;
PATH_WEIGHT:=PATH_WEIGHT-MAX
END { IF MAX > 0 }
UNTIL MAX = 0;
INDEX:=1;
FOR I:=1 TO N DO
BEGIN
ROUTE[I]:=INDEX; INDEX:=PTR[INDEX]
END
END;
 
var
W :ARRNN=((0, 0, 0, 3, 3, 6),
(0, 0, 1, 4, 1, 0),
(1, 2, 0, 0, 0, 3),
(4, 5, 0, 0, 0, 3),
(4, 2, 0, 0, 0, 0),
(7, 1, 3, 3, 0, 0)
);
 
PATH_WEIGHT:integer;
ROUTE :ARRN;
i:integer;
begin
PATH_WEIGHT:=0;
for i:=1 to COUNT_POINTS do ROUTE[i]:=i;
FITSP(COUNT_POINTS,1,999999,W,ROUTE,PATH_WEIGHT);
TWOOPT(COUNT_POINTS,W,ROUTE,PATH_WEIGHT);
THREEOPT(COUNT_POINTS,W,ROUTE);
for i:=1 to COUNT_POINTS do write(inttostr(ROUTE[i])+'->');
write(inttostr(1)+' = '+inttostr(PATH_WEIGHT));
end;