Как найти два непересекающихся пути в двунаправленном графе?

У меня есть график с 14 узлами и 21 ссылкой. Этот график показывает оптическую сеть. Ссылки являются двунаправленными, и по каждой ссылке есть несколько ресурсов. Предположим, что существует рабочий путь от источника к получателю, который переносит пакет, содержащий данные, и использует некоторые ресурсы (некоторую часть пропускной способности канала, по которому он проходит). для каждого источника и пункта назначения я должен заранее заранее установить рабочий и защитный пути в случае сбоя соединения, но они не должны быть связаны между собой (они не могут пересекать какую-либо общую ссылку)

Например, я отправляю пакет с узла 1 на узел 4 по маршруту<1,2,3,4> как рабочий путь.
Если ссылка 1-2 не работает, я должен отправить пакет по заранее установленному пути защиты, который не связан с рабочим путем. например, мой путь защиты может быть <1,9,3,4>.

Цель состоит в том, чтобы написать код на C / C ++, чтобы найти путь защиты, который не связан с рабочим путем. На самом деле я не мог понять, как это сделать. Любая помощь будет принята с благодарностью.

Это часть моего кода, в которой я выделил ресурсы для рабочих путей, я не знаю, как я могу сделать то же самое для установления защитного пути при условии, что он не должен быть связан с рабочим путем.

 int required_fs;
int des;
int idpk;
double holding;
int src;

//get the information about the packet that is sent from source to destination.
Packet *pkptr;
pkptr = op_pk_get (0);
op_pk_nfd_get(pkptr,"bw_fs",&required_fs);
op_pk_nfd_get(pkptr,"des",&des);
op_pk_nfd_get(pkptr,"src",&src);
op_pk_nfd_get(pkptr,"id",&idpk);
op_pk_nfd_get(pkptr,"ht",&holding);bw_req=bw_req + required_fs;
number_of_req=number_of_req+1;

if (number_of_req > 1000000)
{
FILE* file1=fopen("C:/400f_rsa.txt","a+");
fprintf(file1,"\n");
fprintf(file1,"number_of_req ,number_of_nack,number_of_ack , bw_req , bw_nack , bw_ack " );
fprintf(file1,"\n");
fprintf(file1,"  %d , %d , %d , %d , %d , %d   ", number_of_req, number_of_nack ,number_of_ack,bw_req,bw_nack,bw_ack );
fprintf(file1,"\n");
fprintf(file1,"------------------------------- ");
fclose (file1);
op_sim_end("1000000 paket","","","");

}

//  Allocate the resources on each link to the working path, This part must be the same for the protection path too.
int determined_t=0;
int determined_r=0;
int determined_p_f=0;
int determined_p_e=0;
int determined_k=0;

for ( int i=1; i<=10; i++)
{
if (transmitter[src][i]==0)
{
determined_t=i;
break;
}
}

if (determined_t!=0)
{
for ( int i=1; i<=10; i++)
{
if (reciever[des][i]==0)
{
determined_r=i;
break;
}
}

if (determined_r!=0)
{

for ( int k=1; k<=2 ; k++)
{

determined_p_f=0;
determined_p_e=0;
int count = paths_node[src][des][k][2][14];

zero_array();

for (int i=1; i<=count; i++)
{
finding_fs( k, i, des, src );
}
if ( ff_rr==0)
{//ff
////checking gap
determined_p_f=find_first_free_gap(required_fs);
if (determined_p_f!=0)
{
determined_p_e=determined_p_f+required_fs-1;
if (determined_p_e != 1000)
{
determined_p_e=determined_p_e+1;
}
determined_k=k;
break;
}}
else if (ff_rr==1)
{//rr
clear_rr_gap();
find_rr_gap(required_fs);
int index=rr_spectrum();
determined_p_f=ary_rr[index].first;
if (determined_p_f!=0)
{
determined_p_e=ary_rr[index].last;
determined_k=k;
break;
}

}}

if (determined_p_f!=0)
{
//add to ls , applying
int count_link = paths_node[src][des][determined_k][2][14];

for ( int i=1; i<=count_link ; i++)
{
int num_link_p=paths_node[src][des][determined_k][2][i];

for ( int j=determined_p_f ; j<=determined_p_e; j++)
{
links_fs[num_link_p][j]=1;

}
}

reciever[des][determined_r]=1;
transmitter[src][determined_t]=1;
ls(determined_p_f,determined_p_e,determined_r,determined_t,determined_k,src,des,idpk);

number_of_ack= number_of_ack +1 ;
bw_ack= bw_ack + required_fs;
op_intrpt_schedule_self(op_sim_time ()+ holding,idpk);
op_pk_destroy(pkptr);
}
else
{
number_of_nack=number_of_nack+1;
bw_nack= bw_nack + required_fs;
op_pk_destroy(pkptr);
}
}
else
{
number_of_nack=number_of_nack+1;
bw_nack= bw_nack + required_fs;
op_pk_destroy(pkptr);
}
}
else
{
number_of_nack=number_of_nack+1;
bw_nack= bw_nack + required_fs;
op_pk_destroy(pkptr);
}