题目链接

最大流+技巧

题意：每条光纤都有流量上线，如果扩展某一条光纤的上限，能让总部的接收总流量增加，那么这条光纤就符合题目的条件，输出所有满足题目条件的光纤编号(从小到大)。

建图跑一次最大流之后，会存在若干条满流的边，答案要求的边就在这些满流的边之中，但并不是说每一条满流的边都是符合题目条件的，比如说：
一条增广路有超过1条满流的边，但是扩展其中某一条边的容量，总流量是不会增加的。

对于某一条满流的边，我们如果知道左端点到源点s存在一条不包含满流边的路径，右端点到汇点存在一条不包含满流边的路径，那么当前这条满流边就是可取的。
所以分别从源点和汇点dfs标记一次就行了。

#pragma GCC optimize(2)
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <queue>

using namespace std;

typedef long long ll;

const int Maxn = 100+10;
const int INF = 0x3f3f3f3f;
const int Mod = 1e9+7;

struct Edge {
    int v, cap, flow, next;
} edge[Maxn*Maxn];

int h[Maxn], edge_cnt;
int indx[Maxn], deep[Maxn];
int ans[Maxn*Maxn];
bool from[Maxn], to[Maxn];

void add(int u, int v, int c) {
    edge[edge_cnt].v = v;
    edge[edge_cnt].cap = c;
    edge[edge_cnt].flow = 0;
    edge[edge_cnt].next = h[u];
    h[u] = edge_cnt++;

    edge[edge_cnt].v = u;
    edge[edge_cnt].cap = 0;
    edge[edge_cnt].flow = 0;
    edge[edge_cnt].next = h[v];
    h[v] = edge_cnt++;
}

bool bfs(int s, int t) {
    memset(deep, -1, sizeof(deep));
    queue <int> qu;
    qu.push(s); deep[s] = 0;
    while(!qu.empty()) {
        int u = qu.front(); qu.pop();
        for(int i = h[u]; i != -2; i = edge[i].next) {
            Edge e = edge[i];
            if(deep[e.v] == -1 && (e.cap > e.flow)) {
                deep[e.v] = deep[u]+1;
                qu.push(e.v);
            }
        }
    }
    if(deep[t] == -1) return false;
    else return true;
}

int dfs(int u, int t, int a) {
    if(u == t || a == 0) return a;
    if(indx[u] == -1) indx[u] = h[u];
    int flow = 0;
    for(int &i = indx[u]; i != -2; i = edge[i].next) {
        Edge &e = edge[i];
        if(deep[e.v] == deep[u]+1) {
            int f = dfs(e.v, t, min(a, e.cap-e.flow));
            if(f > 0) {
                e.flow += f;
                edge[i^1].flow -= f;
                flow += f;
                a -= f;
                if(a == 0) break;
            }
        }
    }
    return flow;
}

void dinic(int s, int t) {
    int flow = 0;
    while(bfs(s, t)) {
        memset(indx, -1, sizeof(indx));
        flow += dfs(s, t, INF);
    }
}

void mark(int u, int flag, bool *tmp) {
    tmp[u] = true;
    for(int i = h[u]; i != -2; i = edge[i].next) {
        Edge &e = edge[i];
        if(flag == 1) {
            if(tmp[e.v] || e.cap == 0) continue;
            if(e.cap > e.flow) mark(e.v, flag, tmp);
        } else {
            if(tmp[e.v] || e.cap > 0) continue;
            if(edge[i^1].cap > edge[i^1].flow) mark(e.v, flag, tmp);
        }
    }
}

int main(void)
{
	int n, m, L;
	while(scanf("%d%d%d", &n, &m, &L) != EOF) {
        if(!n && !m && !L) break;
        for(int i = 0; i <= n+m+2; ++i) h[i] = -2;
        edge_cnt = 0;
        int u, v, c, s = n+m+1;
        for(int i = 0; i < L; ++i) {
            scanf("%d%d%d", &u, &v, &c);
            add(u, v, c);
        }
        for(int i = 1; i <= n; ++i) add(s, i, INF);
        dinic(s, 0);

        memset(from, false, sizeof(from));
        memset(to, false, sizeof(to));

        mark(s, 1, from);
        mark(0, 2, to);

        int cnt = 0;
        for(int i = 1; i <= n+m; ++i) {
            for(int j = h[i]; j != -2; j = edge[j].next) {
                Edge e = edge[j];
                if(e.cap > 0 && e.cap == e.flow) {
                    if(from[i] && to[e.v]) ans[cnt++] = ((j^1)+1)/2;
                }
            }
        }

        sort(ans, ans+cnt);
        for(int i = 0; i < cnt; ++i) {
            printf("%d", ans[i]);
            if(i < cnt-1) printf(" ");
        }
        puts("");
	}
	return 0;
}