ZOJ 2567 Trade

Trade

Time Limit: 5000ms

Memory Limit: 32768KB

This problem will be judged on ZJU. Original ID: 2567
64-bit integer IO format: %lld      Java class name: Main

Special Judge

In the Middle Ages m European cities imported many goods from n Arabian cities. Due to continous feudal wars, European cities did not trade with each other, so is some European city needed some Arabian goods, the special trade route was established for this particular trade.

Studying the manuscripts historians have found out that each European city imported goods from at least two Arabian cities, and each Arabian city exported goods to at least two European cities. They have also investigated different factors and identified all potential trade routes (trade routes between some pairs of cities were impossible due to various reasons).

Now historians wonder, what is the minimal possible number of trade routes, that could have existed. Help them to find that out.

Input

The first line of the input file contains m, n, and p - the number of European and Arabian cities respectively, and the number of potential trade routes (1 <= m, n <= 300, 1 <= p <= nm). The following p lines describe potential trade routes, each description consists of two numbers - the European and the Arabian city connected by the route.

Output

On the first line of the output file print k - the minimal possible number of trade routes that could have existed. After that output k numbers - some minimal set of routes that might have existed to satisfy all conditions. Routes are numbered starting from 1 as they are given in the input file.

If historians must have made a mistake and it is impossible to satisfy the specified conditions, print -1 on the first and the only line of the output file.

Sample Input

5 5 14
1 2
1 3
1 4
1 5
2 1
2 5
3 1
3 5
4 1
4 5
5 1
5 2
5 3
5 4

Sample Output

12
1 2 3 5 6 7 8 9 10 12 13 14

 

Source

Andrew Stankevich's Contest #4

Author

Andrew Stankevich

 

解题：有源汇的上下界最小流

1. 先按无源汇的上下界可行流建图
2. 对S到T跑最大流$f_1$,然后连接$<T,S,INF>$，再跑次最大流$f_2$
3. 如果$f_1+f_2=\sum_{du[i]>0}{du[i]}$则存在可行流，此时边$<T,S>$的反向弧的流量即是最小流
4. 然后输出不在残量网络上的边

 #include <bits/stdc++.h>
 using namespace std;
 const int INF = 0x3f3f3f3f;
 const int maxn = ;
 struct arc{
     int to,flow,next;
     arc(int x = ,int y = ,int z = -){
         to = x;
         flow = y;
         next = z;
     }
 }e[];
 int head[maxn],cur[maxn],d[maxn],du[maxn],tot;
 void add(int u,int v,int flow){
     e[tot] = arc(v,flow,head[u]);
     head[u] = tot++;
     e[tot] = arc(u,,head[v]);
     head[v] = tot++;
 }
 bool bfs(int S,int T){
     queue<int>q;
     memset(d,-,sizeof d);
     d[S] = ;
     q.push(S);
     while(!q.empty()){
         int u = q.front();
         q.pop();
         for(int i = head[u]; ~i; i = e[i].next){
             if(e[i].flow && d[e[i].to] == -){
                 d[e[i].to] = d[u] + ;
                 q.push(e[i].to);
             }
         }
     }
     return d[T] > -;
 }
 int dfs(int u,int T,int low){
     if(u == T) return low;
     int a,tmp = ;
     for(int &i = cur[u]; ~i; i = e[i].next){
         if(e[i].flow && d[e[i].to] == d[u] +&&(a=dfs(e[i].to,T,min(e[i].flow,low)))){
             e[i].flow -= a;
             e[i^].flow += a;
             low -= a;
             tmp += a;
             if(!low) break;
         }
     }
     if(!tmp) d[u] = -;
     return tmp;
 }
 int dinic(int S,int T,int ret = ){
     while(bfs(S,T)){
         memcpy(cur,head,sizeof head);
         ret += dfs(S,T,INF);
     }
     return ret;
 }
 int main(){
     int n,m,p,u,v;
     while(~scanf("%d%d%d",&n,&m,&p)){
         memset(head,-,sizeof head);
         memset(du,,sizeof du);
         int S = tot = ,T = n + m + ,SS = T + ,TT = SS + ;
         for(int i = ; i < p; ++i){
             scanf("%d%d",&u,&v);
             add(u,v + n,);
         }
         for(int i = ; i <= n; ++i){
             add(S,i,INF);
             du[S] -= ;
             du[i] += ;
         }
         for(int i = ; i <= m; ++i){
             add(i + n,T,INF);
             du[i + n] -= ;
             du[T] += ;
         }
         int sum = ;
         for(int i = S; i <= T; ++i){
             if(du[i] > ){
                 add(SS,i,du[i]);
                 sum += du[i];
             }else add(i,TT,-du[i]);
         }
         u = dinic(SS,TT);
         add(T,S,INF);
         if(u + dinic(SS,TT) == sum){
             bool flag = false;
             printf("%d\n",e[tot-].flow);
             for(int i = ; i < p; ++i)
                 if(!e[i*].flow){
                     if(flag) putchar(' ');
                     flag = true;
                     printf("%d",i + );
                 }
             puts("");
         }else puts("-1");
     }
     return ;
 }