void main()
{ int i,j,n;
cout<<"请输入有向图节点，以-1 -1结束，和节点个数n:"<<endl;
cin>>i>>j;
while(i!=-1 && j!=-1)
{
if(i<0||j<0)
{
cout<<"输入错误"<<endl;
exit(-2);
}
arc[i][j]=1;
cin>>i>>j;
}
cin>>n;
if(n<1||n>Maxnode)
{
cout<<"错误,节点数必须是在1到"<<Maxnode<<"之间的数!"<<endl;
exit(-2);
}
cout<<"对应的邻接矩阵如下："<<endl;
showMG(n);
topsort(n);
}
// Test Topological Sort with BFS (queue)
// Version for Adjancency List representation
int main(int argc, char** argv) {
Graph* G;
FILE *fid;
if (argc != 2) {
cout << "Usage: grdfsm <file>\n";
exit(-1);
}
if ((fid = fopen(argv[1], "rt")) == NULL) {
cout << "Unable to open file |" << argv[1] << "|\n";
exit(-1);
}
G = createGraph<Graphl>(fid);
if (G == NULL) {
cout << "Unable to create graph\n";
exit(-1);
}
Queue<int>* Q = new AQueue<int>(G->n());
topsort(G, Q);
cout << endl;
return 0;
}
void topsort(int dp,int cnt)
{
if(dp>=cnt)
{
for(int i=0;i<dp;i++)
printf("%c",solution[i]+'A');
printf("\n");
}
for(int i=0;i<26;i++)
{
if(vi[i]&&number[i]==0)
{
solution[dp++]=i;
vi[i]=0;
for(int j=1;j<=g1[i][0];j++)
{
number[g1[i][j]]--;
}
topsort(dp,cnt);
dp--;
vi[i]=1;
for(int j=1;j<=g1[i][0];j++)
{
number[g1[i][j]]++;
}
number[i]=0;
}
}
}
void main(int argc, char *argv[])
{
int V, E;
if (argc < 2)
fp = stdin;
else
if ((fp = fopen(argv[1], "rt")) == NULL)
{
printf("\n That file does not exist!");
exit(1);
}
input_adjlist(network, &V, &E);
printf("\n\nAdjacency List representaion for graph");
print_adjlist(network, V);
printf("\n\nSet count to indegree");
set_count_indegree(network, V);
print_adjlist(network, V);
printf("\n\nTopological order\n");
topsort(network, V);
getch();
printf("\n\nSet count to outdegree");
set_count_outdegree(network, V);
print_adjlist(network, V);
printf("\n\nReverse Topological order\n");
revtopsort(network, V);
}
int main(void) {
int N = -1, M = -1;
FILE * in, * out;
struct node ** lists = NULL;
struct node ** tmp = NULL;
in = fopen(INPUT_FILE, "r");
out = fopen(OUTPUT_FILE, "w");
readFirstValues(in, &N, &M, out);
allocMemForLists(&lists, N);
tmp = getValues(N, M, lists, in, out);
if (topsort(lists, N, out)) {
remove_lists(lists, N);
free(tmp);
free(lists);
ERROR(out, ERROR_CYCLE);
}
remove_lists(lists, N);
free(tmp);
free(lists);
fclose(in);
fclose(out);
return(0);
}
int main(void)
{
struct graph g;
int k;
graph_creat(&g, "graph.txt", 1); // create DAG
graph_print(&g);
topsort(&g);
printf("topological sort: ");
for (k = 0; k < g.nnode; k++)
printf("%d-> ", sort[k]);
printf("\n");
return 0;
}
main()
{
graph g;
int out[MAXV];
int i;
read_graph(&g,TRUE);
print_graph(&g);
topsort(&g,out);
for (i=1; i<=g.nvertices; i++)
printf(" %d",out[i]);
printf("\n");
}
int main(int argc, char *argv[])
{
srand(time(NULL));
int arr[100] = { 3, 1, 4, 7, 10, 11 };
int n = 6;
if (argc == 1)
{
printf("Invalid num args\nCommand line input was expected\nRunning with default number\n");
putchar('\n');
int i;
for(i=0; i<n; ++i)
printf("%d ", arr[i]);
putchar('\n');
}
else if (argc == 2)
{
n = atoi(argv[1]);
printf("In : ");
gen(arr, n);
putchar('\n');;
}
else
{
n = atoi(argv[1]);
int i;
printf("In : ");
for(i=0; i<n; ++i)
printf("%d ", arr[i] = atoi(argv[i + 2]));
putchar('\n');;
}
init();
int x = srt(arr, n);
if (x == -INF)
{
printf("No repetitions\n");
}
else
{
printf("Repition :");
printf("%d ", x);
putchar('\n');
}
printf("Topsort: ");
topsort();
putchar('\n');
return 0;
}
void mig_cuts_paged::enumerate()
{
reference_timer t( &_enumeration_time );
/* topsort */
std::vector<unsigned> topsort( num_vertices( _mig ) );
boost::topological_sort( _mig, topsort.begin() );
/* loop */
_top_index = 0u;
for ( auto n : topsort )
{
if ( out_degree( n, _mig ) == 0u )
{
/* constant */
if ( n == 0u )
{
data.assign_empty( 0u, {0u, 0u} );
cones.assign_empty( 0u );
}
/* PI */
else
{
data.assign_singleton( n, n, {0u, 1u} );
cones.assign_singleton( n, n );
}
}
else
{
data.append_begin( n );
cones.append_begin( n );
/* get children */
auto it = adjacent_vertices( n, _mig ).first;
const auto n1 = *it++;
const auto n2 = *it++;
const auto n3 = *it++;
enumerate_node_with_bitsets( n, n1, n2, n3 );
data.append_singleton( n, n, {0u, 1u} );
cones.append_singleton( n, n );
}
_top_index++;
}
}
int main(int argc, const char *argv[])
{
char * v[N] = {"V0", "V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8"};
int edge[N][N]={ //v0 v1 v2 v3 v4 v5 v6 v7 v8
/*v0*/ {0, 1, 1, 0, 0, 0, 0, 0, 0},
/*v1*/ {1, 0, 0, 1, 0, 1, 0, 0, 0},
/*v2*/ {1, 0, 0, 0, 0, 0, 1, 1, 0},
/*v3*/ {0, 1, 0, 0, 1, 0, 0, 0, 0},
/*v4*/ {0, 0, 0, 1, 0, 1, 0, 0, 1},
/*v5*/ {0, 1, 0, 0, 1, 0, 0, 0, 0},
/*v6*/ {0, 0, 1, 0, 0, 0, 0, 1, 0},
/*v7*/ {0, 0, 1, 0, 0, 0, 1, 0, 0},
/*v8*/ {0, 0, 0, 0, 1, 0, 0, 0, 0}
};
mgraph * mg;
mg = mgraph_create(N, v, edge);
//int visited[N] = {0};
//DFS(mg, 0, visited);
_DFS(mg, 0);
puts("");
_BFS(mg, 0);
if (topsort(mg)) {
printf("not cycle\n");
}
else {
printf("cycle\n");
}
//int (*p)[N];
// p = edge;
#if 0
int u = firstadj(mg, 7);//u=1
printf("%d %s \n", u, v[u]);//1 V1
u = nextadj(mg, 7, u);//u=2
printf("%d %s \n", u, v[u]);//1 V1
#endif
return 0;
}
std::vector<std::pair<unsigned, unsigned>> compute_level_ranges( const mig_graph& mig, unsigned& max_level )
{
auto sa_settings = std::make_shared<properties>();
auto sa_statistics = std::make_shared<properties>();
auto output_levels = simulate_mig( mig, mig_depth_simulator(), sa_settings, sa_statistics );
max_level = 0u;
const auto& info = mig_info( mig );
for ( const auto& o : info.outputs )
{
max_level = std::max( max_level, output_levels.at( o.first ) );
}
auto levels = sa_statistics->get<std::map<mig_node, unsigned>>( "node_values" );
std::vector<std::pair<unsigned, unsigned>> level_ranges( num_vertices( mig ) );
std::vector<mig_node> topsort( boost::num_vertices( mig ) );
boost::topological_sort( mig, topsort.begin() );
auto ingoing = precompute_ingoing_edges( mig );
for ( const auto& v : topsort )
{
auto it = ingoing.find( v );
/* no ingoing edges (outputs) */
if ( it == ingoing.end() )
{
level_ranges[v] = {levels[v], max_level};
levels[v] = max_level;
continue;
}
const auto min_edge = *boost::min_element( it->second, [&]( const mig_edge& e1, const mig_edge& e2 ) {
return levels.at( boost::source( e1, mig ) ) < levels.at( boost::source( e2, mig ) );
} );
auto to_l = levels.at( boost::source( min_edge, mig ) ) - 1u;
level_ranges[v] = {levels[v], to_l};
levels[v] = to_l;
}
return level_ranges;
}
int main() {
init();
build_graph();
topsort();
sgt::build(0, axis - 1);
int res = inf;
for ( int i = n_stuff - 1; i >= 0; i -- ) {
int t = cmd[i].des;
if ( cmd[i].on ) {
int l = stuff[t].l, r = stuff[t].r - 1;
if ( l <= r ) {
int tmp = sgt::ask_min(l, r);
if ( tmp < val[t] )
res = i;
}
}
if ( stuff[t].r > stuff[t].l )
sgt::cover(stuff[t].l, stuff[t].r - 1, val[t]);
}
return res;
}
int main()
{
while(scanf("%d",&n)!=EOF)
{
int top=-1;
memset(in,0,sizeof(in));
memset(vert,0,sizeof(vert));
for(int i=1;i<=n;i++)
{
int m,x;
scanf("%d%d",&tim[i],&m);
in[i]=m;
for(int j=0;j<m;j++)
{
scanf("%d",&x);
Add_Edge(x,i,top);
}
}
printf("%d\n",topsort());
}
return 0;
}
int main(int argc, const char *argv[])
{
char * v[N] = {"V0", "V1", "V2", "V3", "V4", "V5"};
int edge[N][N]={
/* v0 v1 v2 v3 v4 v5 */
/*v0*/ {0, 1, 0, 1, 1, 0},
/*v1*/ {0, 0, 0, 0, 0, 1},
/*v2*/ {0, 1, 0, 0, 0, 1},
/*v3*/ {0, 0, 0, 0, 0, 0},
/*v4*/ {0, 0, 0, 1, 0, 1},
/*v5*/ {0, 0, 0, 0, 0, 0}};
mgraph * mg;
mg = mgraph_create(N, v, edge);
if (topsort(mg)) {
printf("not cycle\n");
}
else {
printf("cycle\n");
}
return 0;
}
int main()
{
while(1==scanf("%d",&n))
{
memset(g,0,sizeof(g));
memset(vi,0,sizeof(vi));
memset(gg,-1,sizeof(gg));
memset(number,0,sizeof(number));
memset(g1,0,sizeof(g1));
frame fp[41];
scanf("%d",&m);
for(int i=1;i<=n;i++)
scanf("%s",mp[i]+1);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
if(mp[i][j]=='.')
continue;
int a=mp[i][j]-'A';
gg[i][j]=a;
vi[a]=1;
if(fp[a].x1>i)fp[a].x1=i;
if(fp[a].y1>j)fp[a].y1=j;
if(fp[a].x2<i)fp[a].x2=i;
if(fp[a].y2<j)fp[a].y2=j;
}
int cnt=build(fp);
/* for(int i=0;i<=4;i++)
printf("%d %d %d %d\n",fp[i].x1,fp[i].y1,fp[i].x2,4fp[i].y2);
for(int i=0;i<26;i++)
if(number[i])
printf("%d ",i); */
topsort(0,cnt);
}
return 0;
}
abc::Gia_Man_t* cirkit_to_gia( const aig_graph& aig )
{
const auto& info = aig_info( aig );
const unsigned _num_inputs = info.inputs.size();
const unsigned _num_outputs = info.outputs.size();
const unsigned _num_latches = info.cis.size();
const unsigned _num_vertices = num_vertices( aig ) - 1u;
const unsigned _num_gates = _num_vertices - _num_latches - _num_inputs;
assert( _num_vertices == _num_inputs + _num_latches + _num_gates );
/* allocate an empty aig in abc */
abc::Gia_Man_t * gia = abc::Gia_ManStart( _num_vertices + _num_latches + _num_outputs + 1u );
gia->nConstrs = 0;
gia->pName = strcpy( (char*)malloc( sizeof( char ) * ( info.model_name.size() + 1u ) ), info.model_name.c_str() );
std::vector< int > node_to_obj( boost::num_vertices( aig ) );
node_to_obj[0] = 0;
/* inputs */
assert( !gia->vNamesIn );
gia->vNamesIn = abc::Vec_PtrStart( info.inputs.size() );
for ( const auto& input : index( info.inputs ) )
{
const int obj = abc::Gia_ManAppendCi( gia );
node_to_obj[input.value] = abc::Abc_Lit2Var( obj );
const auto name = info.node_names.at( input.value );
abc::Vec_PtrSetEntry( gia->vNamesIn, input.index, strcpy( (char*)malloc( sizeof( char ) * ( name.size() + 1u ) ), name.c_str() ) );
}
/* latches */
assert( info.cis.size() == info.cos.size() );
assert( _num_latches == 0u );
/* and gates */
std::vector<unsigned> topsort( boost::num_vertices( aig ) );
boost::topological_sort( aig, topsort.begin() );
for ( const auto& node : topsort )
{
if ( !boost::out_degree( node, aig ) ) { continue; }
const auto children = get_children( aig, node );
assert( children.size() == 2u );
const int obj = Gia_ManAppendAnd2_Simplified( gia,
abc::Abc_Var2Lit( node_to_obj[children[0].node], children[0].complemented ),
abc::Abc_Var2Lit( node_to_obj[children[1].node], children[1].complemented ) );
node_to_obj[node] = abc::Abc_Lit2Var( obj );
}
/* outputs */
assert( !gia->vNamesOut );
gia->vNamesOut = abc::Vec_PtrStart( info.outputs.size() );
for ( const auto& output : index( info.outputs ) )
{
abc::Gia_ManAppendCo( gia, abc::Abc_Var2Lit( node_to_obj[output.value.first.node], output.value.first.complemented ) );
const auto name = output.value.second;
abc::Vec_PtrSetEntry( gia->vNamesOut, output.index, strcpy( (char*)malloc( sizeof( char ) * ( name.size() + 1u ) ), name.c_str() ) );
}
return gia;
}
void map()
{
auto names = boost::get( boost::vertex_name, lut );
auto tts = boost::get( boost::vertex_lut, lut );
auto types = boost::get( boost::vertex_lut_type, lut );
std::vector<lut_vertex_t> topsort( num_vertices( lut ) );
boost::topological_sort( lut, topsort.begin() );
for ( auto v : topsort )
{
switch ( types[v] )
{
case lut_type_t::internal:
{
std::vector<xmg_function> pi_mapping;
for ( const auto& child : boost::make_iterator_range( boost::adjacent_vertices( v, lut ) ) )
{
pi_mapping.push_back( node_to_function[child] );
}
/* some special cases */
if ( boost::out_degree( v, lut ) <= 1u )
{
if ( tts[v] == "2" )
{
node_to_function[v] = pi_mapping.front();
break;
}
else if ( tts[v] == "1" )
{
node_to_function[v] = !pi_mapping.front();
break;
}
std::cout << "[e] special case for " << tts[v] << " with " << boost::out_degree( v, lut ) << " input missing" << std::endl;
assert( false );
}
const auto it = optimal_xmgs.find( tts[v] );
assert ( it != optimal_xmgs.end() );
const auto opt_xmg = it->second;
if ( opt_xmg.inputs().size() != boost::out_degree( v, lut ) )
{
boost::dynamic_bitset<> phase;
std::vector<unsigned> perm;
tt orig( convert_hex2bin( tts[v] ) );
auto npn = npn_canonization_lucky( orig, phase, perm );
std::cout << "[e] problem when mapping LUT " << v << " with TT " << tts[v] << " to XMG" << std::endl;
std::cout << "[e] LUT has " << boost::out_degree( v, lut ) << " inputs" << std::endl;
std::cout << "[e] XMG has " << opt_xmg.inputs().size() << " inputs" << std::endl;
std::cout << "[e] TT: " << orig << ", NPN: " << npn << std::endl;
assert( false );
}
const auto outputs = xmg_rewrite_top_down_inplace( xmg, opt_xmg, rewrite_default_maj, rewrite_default_xor, pi_mapping );
if ( outputs.size() != 1u )
{
std::cout << "[e] expected: 1, got: " << outputs.size() << std::endl;
assert( false );
}
node_to_function[v] = outputs.front();
} break;
case lut_type_t::po:
{
xmg.create_po( node_to_function[*boost::adjacent_vertices( v, lut ).first], names[v] );
} break;
default:
break;
}
}
}
