[kuangbin]带你飞之'连通图'专题

带飞网址┗|｀O′|┛ 嗷~~

专题九 连通图 
√ POJ 1236 Network of Schools
√ UVA 315 Network
√ UVA 796 Critical Links
√ POJ 3694 Network
√ POJ 3177 Redundant Paths
√ HDU 4612 Warm up
√ HDU 4635 Strongly connected
√ HDU 4685 Prince and Princess
√ HDU 4738 Caocao's Bridges

// poj 1236

#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN = 100+5;
const int MAXM = MAXN*MAXN;

int num;
int head[MAXN];
struct node {
    int v, next;
} edge[MAXM];

inline void add(int x, int y) {
    edge[num].v = y;
    edge[num].next = head[x];
    head[x] = num++;
}

int cnt, t, scc_cnt;
int dfn[MAXN], low[MAXN], vis[MAXN], sccno[MAXN], stack[MAXN];
void Tarjan(int cur) {
    dfn[cur] = low[cur] = ++cnt;
    vis[cur] = 1;
    stack[t++] = cur;
    for(int i = head[cur]; i != -1; i = edge[i].next) {
        if(!dfn[edge[i].v]) {
            Tarjan(edge[i].v);
            low[cur] = min(low[cur], low[edge[i].v]);
        }
        else if(vis[edge[i].v]) {
            low[cur] = min(low[cur], dfn[edge[i].v]);
        }
    }
    if(dfn[cur] == low[cur]) {
        ++scc_cnt;
        int v;
        do {
            v = stack[--t];
            sccno[v] = scc_cnt;
            vis[v] = 0;
        } while(v != cur);
    }
}

int n;
int in[MAXN], out[MAXN];

int main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n;
    num = 0;
    for(int i = 1; i <= n; ++i) head[i] = -1;
    int v;
    for(int u = 1; u <= n; ++u) {
        while(cin >> v && v) {
            add(u, v);
        }
    }
    cnt = t = scc_cnt = 0;
    for(int i = 1; i <= n; ++i) {
        if(!dfn[i]) Tarjan(i);
    }
    for(int i = 1; i <= n; ++i) {
        for(int j = head[i]; j != -1; j = edge[j].next) {
            if(sccno[i] != sccno[edge[j].v]) {
                ++out[sccno[i]]; ++in[sccno[edge[j].v]];
            }
        }
    }
    int inn = 0, outn = 0;
    for(int i = 1; i <= scc_cnt; ++i) {
        if(!in[i]) ++inn;
        if(!out[i]) ++outn;
    }
    if(scc_cnt == 1) cout << "1
0
";
    else cout << inn << "
" << max(inn, outn) << "
";
    return 0;
}

 // UVA 315

/*
 * @Promlem: 
 * @Time Limit: ms
 * @Memory Limit: k
 * @Author: pupil-XJ
 * @Date: 2019-10-30 23:24:12
 * @LastEditTime: 2019-10-31 00:22:49
 */
#include<cstdio>
#include<cstring>
#include<cmath>
#include<fstream>
#include<iostream>
#include<string>
#include<functional>
#include<algorithm>
#include<sstream>
#include<iomanip>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define read(n) n = read_n()
#define rep(i, n) for(int i=0;i!=n;++i)
#define per(i, n) for(int i=n-1;i>=0;--i)
#define Rep(i, sta, n) for(int i=sta;i!=n;++i)
#define rep1(i, n) for(int i=1;i<=n;++i)
#define per1(i, n) for(int i=n;i>=1;--i)
#define Rep1(i, sta, n) for(int i=sta;i<=n;++i)
#define L k<<1
#define R k<<1|1
#define mid (tree[k].l+tree[k].r)>>1
#define eps 1e-10
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;

inline int read_n() {
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
// -----------------------------------------------------
const int MAXN = 100+5;
const int MAXM = MAXN*MAXN;

int num;
int head[MAXN];
struct node {
    int v, next;
} edge[MAXM];

inline void add(int x, int y) {
    edge[num].v = y;
    edge[num].next = head[x];
    head[x] = num++;
}

int n;
int cnt;
int dfn[MAXN], low[MAXN];
set<int> disct;

void Tarjan(int cur, int root) {
    dfn[cur] = low[cur] = ++cnt;
    int flag = 0;
    for(int i = head[cur]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(!dfn[v]) {
            Tarjan(v, root);
            low[cur] = min(low[cur], low[v]);
            if(low[v] >= dfn[cur]) {
                ++flag;
                if(cur != root || flag > 1) disct.insert(cur);    
            }
        }
        else low[cur] = min(low[cur], dfn[v]);
    }
}

void solve() {
    cnt = 0;
    disct.clear();
    rep1(i, n) dfn[i] = low[i] = 0;
    rep1(i, n) if(!dfn[i]) Tarjan(i, i);
    cout << disct.size() << "
";
}

int main() {
    while(cin >> n && n) {
        num = 0;
        rep1(i, n) head[i] = -1;
        int u, v;
        while(cin >> u && u) {
            while(getchar() != '
') {
                cin >> v;
                add(u, v); add(v, u);
            }
        }
        solve();
    }
    return 0;
}

 // UVA 796

All
Mine
Followed
Previous12345…NextFilterReset
Username

OJ
    Prob

796
Result 
    Time
(ms)    Mem
(MB)    Lang 
    Submit Time
Arnoiii
UVA    
796
Accepted
0        
C++
14 min ago
445514922
UVA    
796
Accepted
0        
C++
10 hr ago
445514922
UVA    
796
Accepted
0        
C++
10 hr ago
445514922
UVA    
796
Accepted
0        
C++
10 hr ago
445514922
UVA    
796
Wrong answer
C++
10 hr ago
445514922
UVA    
796
Wrong answer
C++
10 hr ago
445514922
UVA    
796
Wrong answer
C++
10 hr ago
445514922
UVA    
796
Wrong answer
C++
10 hr ago
ori_arevalos
UVA    
796
Wrong answer
Python
2 days ago
ori_arevalos
UVA    
796
Wrong answer
Python
2 days ago
ori_arevalos
UVA    
796
Wrong answer
Python
2 days ago
zyq2652192993
UVA    
796
Accepted
0        
C++
2 days ago
zyq2652192993
UVA    
796
Wrong answer
C++
2 days ago
zyq2652192993
UVA    
796
Wrong answer
C++
2 days ago
zyq2652192993
UVA    
796
Compilation error
C++
2 days ago
zyq2652192993
UVA    
796
Compilation error
C++
2 days ago
Ada_Boost
UVA    
796
Accepted
0        
C++
3 days ago
A19180294
UVA    
796
Accepted
0        
C++
7 days ago
A19180294
UVA    
796
Compilation error
C++
7 days ago
A19180294
UVA    
796
Accepted
0        
C++
7 days ago
           
All Copyright Reserved © 2010-2019 Xu Han
Server Time: 2019-10-31 02:44:32 CST

#22576444 | Arnoiii's solution for [UVA-796]
Status
Accepted
Length
1677
Lang
C++11 5.3.0
Submitted
2019-10-31 02:29:43
Shared

RemoteRunId
24127850
Select Code
/*
 * @Promlem: 
 * @Time Limit: ms
 * @Memory Limit: k
 * @Author: pupil-XJ
 * @Date: 2019-10-31 01:44:42
 * @LastEditTime: 2019-10-31 02:23:39
 */
#include<cstdio>
#include<algorithm>
#include<vector>
#define rep(i, n) for(int i=0;i!=n;++i)
#define rep1(i, n) for(int i=1;i<=n;++i)
using namespace std;
const int MAXN = 1000+5;
const int MAXM = MAXN*MAXN;
typedef pair<int,int> Pair;

int num;
int head[MAXN];
struct node {
    int v, next;
} edge[MAXM];

inline void add(int x, int y) {
    edge[num].v = y;
    edge[num].next = head[x];
    head[x] = num++;
}

int cnt;
int dfn[MAXN], low[MAXN], pre[MAXN];
void Tarjan(int cur, int fa) {
    dfn[cur] = low[cur] = ++cnt;
    pre[cur] = fa;
    bool flag = false;
    for(int i = head[cur]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(v == fa && !flag) {
            flag = true;
            continue;
        }
        if(!dfn[v]) {
            Tarjan(v, cur);
            low[cur] = min(low[cur], low[v]); 
        }
        else if(v != fa) low[cur] = min(low[cur], dfn[v]);
    }
}

int n;
vector<Pair> ans;

void solve() {
    cnt = 0;
    ans.clear();
    rep(i, n) pre[i] = -1, dfn[i] = 0;
    rep(i, n) if(!dfn[i]) Tarjan(i, -1);
    rep(v, n) {
        int u = pre[v];
        if(u != -1 && dfn[u] < low[v]) {
            if(u < v) ans.push_back(make_pair(u, v));
            else ans.push_back(make_pair(v, u));
        }
    }
    sort(ans.begin(), ans.end());
    printf("%d critical links
",ans.size());
    rep(i, ans.size()) {
        printf("%d - %d
",ans[i].first,ans[i].second);
    }
    printf("
");
}

int main() {
    while(scanf("%d", &n) == 1) {
        num = 0;
        rep(i, n) head[i] = -1;
        int u, v, nm;
        rep(i, n) {
            scanf("%d (%d)", &u, &nm);
            rep(j, nm) {
                scanf("%d", &v);
                if(u < v) add(u, v), add(v, u);
            }
        }
        solve();
    }
    return 0;
}

 // poj 3694

/*
 * @Promlem: 
 * @Time Limit: ms
 * @Memory Limit: k
 * @Author: pupil-XJ
 * @Date: 2019-10-31 10:02:18
 * @LastEditTime: 2019-10-31 12:51:20
 */
#include<cstdio>
#include<algorithm>
#include<map>
#define rep(i, n) for(int i=0;i!=n;++i)
#define rep1(i, n) for(int i=1;i<=n;++i)
using namespace std;

inline int read() {
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
// --------------------------------------------
const int MAXN = 100000+5;
const int MAXM = 402000+5;

int num;
int head[MAXN];
struct node {
    int v, next;
} edge[MAXM];

inline void add(int x, int y) {
    edge[num].v = y;
    edge[num].next = head[x];
    head[x] = num++;
}

int n, m, q;
int cnt, ans;
int dfn[MAXN], low[MAXN], pre[MAXN], deep[MAXN];
bool bridge[MAXN];

void Tarjan(int cur, int fa) {
    dfn[cur] = low[cur] = ++cnt;
    for(int i = head[cur]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(!dfn[v]) {
            deep[v] = deep[cur] + 1;
            pre[v] = cur;
            Tarjan(v, cur);
            low[cur] = min(low[cur], low[v]);
            if(low[v] > dfn[cur]) bridge[v] = true, ++ans;
        }
        else if(v != fa) low[cur] = min(low[cur], dfn[v]);
    }
}

int LCA(int x, int y) {
    if(deep[x] < deep[y]) swap(x, y);
    while(deep[x] != deep[y]) {
        if(bridge[x]) --ans, bridge[x] = false;
        x = pre[x];
    }
    while(x != y) {
        if(bridge[x]) --ans, bridge[x] = false;
        if(bridge[y]) --ans, bridge[y] = false;
        x = pre[x]; y = pre[y];
    }
    return ans;
}

void solve(int qaq) {
    cnt = ans = 0;
    rep1(i, n) bridge[i] = false;
    rep1(i, n) dfn[i] = 0;
    deep[1] = 1;
    Tarjan(1, 0);
    printf("Case %d:
", qaq);
    q = read();
    int x, y;
    rep(i, q) {
        x = read(); y = read();
        printf("%d
", LCA(x, y));
    }
    printf("
");
}

int main() {
    int qaq = 1;
    while(scanf("%d%d", &n, &m) == 2 && n) {
        num = 0;
        rep1(i, n) head[i] = -1;
        int x, y;
        rep(i, m) {
            x = read(); y = read();
            add(x, y); add(y, x);
        }
        solve(qaq++);
    }
    return 0;
}

 // poj 3177

/*
 * @Promlem: 
 * @Time Limit: ms
 * @Memory Limit: k
 * @Author: pupil-XJ
 * @Date: 2019-10-31 17:35:38
 * @LastEditTime: 2019-10-31 23:03:56
 */
#include<cstdio>
#include<cstring>
#include<cmath>
#include<fstream>
#include<iostream>
#include<string>
#include<functional>
#include<algorithm>
#include<sstream>
#include<iomanip>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define read(n) n = read_n()
#define rep(i, n) for(int i=0;i!=n;++i)
#define per(i, n) for(int i=n-1;i>=0;--i)
#define Rep(i, sta, n) for(int i=sta;i!=n;++i)
#define rep1(i, n) for(int i=1;i<=n;++i)
#define per1(i, n) for(int i=n;i>=1;--i)
#define Rep1(i, sta, n) for(int i=sta;i<=n;++i)
#define L k<<1
#define R k<<1|1
#define mid (tree[k].l+tree[k].r)>>1
#define eps 1e-10
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;

inline int read_n() {
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
// -----------------------------------------------------
const int MAXN = 5000+5;
const int MAXM = 20000+5;

int num;
int head[MAXN];
struct node {
    int v, next;
} edge[MAXM];

inline void add(int x, int y) {
    edge[num].v = y;
    edge[num].next = head[x];
    head[x] = num++;
}

int n, m;

int cnt, scc_cnt, t;
int dfn[MAXN], low[MAXN], vis[MAXN], st[MAXN], sccno[MAXN];

void Tarjan(int cur, int edge_num) {
    dfn[cur] = low[cur] = ++cnt;
    vis[cur] = 1;
    st[t++] = cur;
    for(int i = head[cur]; i != -1; i = edge[i].next) {
        if(edge_num != -1 && i == (edge_num^1)) continue;
        int v = edge[i].v;
        if(!dfn[v]) {
            Tarjan(v, i);
            low[cur] = min(low[cur], low[v]);
        }
        else if(vis[v]) low[cur] = min(low[cur], dfn[v]);
    }
    if(dfn[cur] == low[cur]) {
        ++scc_cnt;
        int v;
        do {
            v = st[--t];
            sccno[v] = scc_cnt;
            vis[v] = 0;
        } while(v != cur);
    }
}

set<int> edg[MAXN];
void solve() {
    cnt = scc_cnt = t = 0;
    rep1(i, n) dfn[i] = vis[i] = 0, edg[i].clear();
    Tarjan(1, -1);
    rep1(i, n) {
        for(int j = head[i]; j != -1; j = edge[j].next) {
            int v = edge[j].v;
            if(sccno[i] != sccno[v]) edg[sccno[i]].insert(sccno[v]), edg[sccno[v]].insert(sccno[i]);
        }
    }
    int sum = 0;
    rep1(i, scc_cnt) if(edg[i].size() == 1) ++sum;
    cout << (sum+1)/2 << "
";
}

int main() {
    //ofstream outputfile;
    //outputfile.open();Output.txt
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    while(cin >> n >> m) {
        num = 0;
        rep1(i, n) head[i] = -1;
        int x, y;
        rep(i, m) {
            cin >> x >> y;
            add(x, y); add(y, x);
        }
        solve();
    }
    
    //outputfile.close();
    return 0;
}

 // poj 4612

/*
 * @Promlem: 
 * @Time Limit: ms
 * @Memory Limit: k
 * @Author: pupil-XJ
 * @Date: 2019-10-31 23:41:06
 * @LastEditTime: 2019-11-01 00:57:51
 */
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<stack>
#define read(n) n = read_n()
#define rep(i, n) for(int i=0;i!=n;++i)
#define rep1(i, n) for(int i=1;i<=n;++i)
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;

inline int read_n() {
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
// -----------------------------------------------------
const int MAXN = 200000+5;
const int MAXM = 2000000+5;

int num;
int head[MAXN];
struct node {
    int v, next;
} edge[MAXM];

inline void add(int x, int y) {
    edge[num].v = y;
    edge[num].next = head[x];
    head[x] = num++;
}

int numt;
int headt[MAXN];
struct t {
    int v, next;
} tree[MAXM];

inline void addt(int x, int y) {
    tree[numt].v = y;
    tree[numt].next = headt[x];
    headt[x] = numt++;
}

int n, m;
int cnt, scc;
int dfn[MAXN], low[MAXN], sccno[MAXN];
bool vis[MAXN];
stack<int> st;

void Tarjan(int cur, int edge_num) {// 无向图缩点
    dfn[cur] = low[cur] = ++cnt;
    vis[cur] = true;
    st.push(cur);
    for(int i = head[cur]; i != -1; i = edge[i].next) {
        if(edge_num != -1 && i == (edge_num^1)) continue;
        int v = edge[i].v;
        if(!dfn[v]) {
            Tarjan(v, i);
            low[cur] = min(low[cur], low[v]);
        }
        else if(vis[v]) low[cur] = min(low[cur], dfn[v]);
    }
    if(dfn[cur] == low[cur]) {
        ++scc;
        int v;
        do {
            v = st.top();
            st.pop();
            vis[v] = false;
            sccno[v] = scc;
        } while(v != cur);
    }
}

int ans;// 树的直径
int dis[MAXN];

void build() {// 建树
    numt = 0;
    rep1(u, n) {
        for(int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].v;
            if(sccno[u] != sccno[v]) {
                addt(sccno[u], sccno[v]);
                addt(sccno[v], sccno[u]);
            }
        }
    }
}

void dp(int cur) {// 树形dp求树的直径
    vis[cur] = true;
    for(int i = headt[cur]; i != -1; i = tree[i].next) {
        int v = tree[i].v;
        if(vis[v]) continue;
        dp(v);
        ans = max(ans, dis[cur] + dis[v] + 1);
        dis[cur] = max(dis[cur], dis[v] + 1);
    }
}

void solve() {
    cnt = scc = 0;
    rep1(i, n) dfn[i] = 0, vis[i] = false, headt[i] = -1;
    Tarjan(1, -1);
    build();
    rep1(i, scc) vis[i] = false, dis[i] = 0;
    ans = 0;
    dp(1);
    cout << scc-1-ans << "
";
}

int main() {
    while(scanf("%d%d", &n, &m) == 2 && n) {
        num = 0;
        rep1(i, n) head[i] = -1;
        int x, y;
        rep(i, m) {
            read(x); read(y);
            add(x, y); add(y, x);
        }
        solve();
    }
    return 0;
}

 // hdu 4635

/*
 * @Promlem: 
 * @Time Limit: ms
 * @Memory Limit: k
 * @Author: pupil-XJ
 * @Date: 2019-11-01 08:09:22
 * @LastEditTime: 2019-11-01 23:53:27
 */
#include<cstdio>
#include<algorithm>
#define read(n) n = read_n()
#define rep(i, n) for(int i=0;i!=n;++i)
#define rep1(i, n) for(int i=1;i<=n;++i)
#define ll long long int
using namespace std;

inline int read_n() {
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
// -----------------------------------------------------
const int MAXN = 100000+5;
const int MAXM = 200000+5;

int num;
int head[MAXN];
struct node {
    int v, next;
} edge[MAXM];

inline void add(int x, int y) {
    edge[num].v = y;
    edge[num].next = head[x];
    head[x] = num++;
}

int n,m;
int cnt, scc, t;
int dfn[MAXN], low[MAXN], sccno[MAXN], st[MAXN], scc_num[MAXN];
bool vis[MAXN];

void Tarjan(int cur) {
    dfn[cur] = low[cur] = ++cnt;
    st[t++] = cur;
    vis[cur] = true;
    for(int i = head[cur]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(!dfn[v]) {
            Tarjan(v);
            low[cur] = min(low[cur], low[v]);
        }
        else if(vis[v]) low[cur] = min(low[cur], dfn[v]);
    }
    if(dfn[cur] == low[cur]) {
        ++scc;
        int v;
        do {
            v = st[--t];
            vis[v] = false;
            sccno[v] = scc;
            ++scc_num[scc];
        } while(v != cur);
    }
}

int in[MAXN], out[MAXN];

void solve(int qaq) {
    cnt = scc = t = 0;
    rep1(i, n) dfn[i] = in[i] = out[i] = scc_num[i] = 0, vis[i] = false;
    rep1(i, n) if(!dfn[i]) Tarjan(i);
    ll ans;
    if(scc == 1) ans = -1;
    else {
        rep1(u, n) {
            for(int i = head[u]; i != -1; i = edge[i].next) {
                int v = edge[i].v;
                if(sccno[u] != sccno[v]) {
                    ++out[sccno[u]]; ++in[sccno[v]];
                }
            }
        }
        ans = 0;
        rep1(i, scc) {
            if(!in[i] || !out[i]) {
                ll a = scc_num[i];
                ll b = n - a;
                ans = max(ans, n*n-a*b-n-m);
            }
        }
    }
    printf("Case %d: %d
", qaq, ans);
}

int main() {
    int T, qaq = 1;
    scanf("%d", &T);
    while(T--) {
        read(n); read(m);
        num = 0;
        rep1(i, n) head[i] = -1;
        int x, y;
        rep(i, m) {
            read(x); read(y);
            add(x, y);
        }
        solve(qaq++);
    }
    return 0;
}

 // hdu 4685

/*
 * @Promlem: 
 * @Time Limit: ms
 * @Memory Limit: k
 * @Author: pupil-XJ
 * @Date: 2019-11-06 20:26:27
 * @LastEditTime: 2019-11-08 10:37:11
 */
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
using namespace std;

inline int read() {
    char c=getchar(); int f=1,x=0;
    while(c<'0'||c>'9') { if(c=='-')f=-1;c=getchar(); }
    while(c>='0'&&c<='9') { x=x*10+c-'0';c=getchar(); }
    return f*x;
}

inline void write(int a) {
    if(a<0)putchar('-'),a=-a;
    if(a>9)write(a/10);
    putchar(a%10+'0');
}
//---------------------------------
const int MAXN = 2000+5;
const int MAXE = 500*500;

int num;
int head[MAXN];
struct node {
    int v, next;
} edge[MAXE];

inline void add(int x, int y) {
    edge[num].v = y;
    edge[num].next = head[x];
    head[x] = num++;
}

int n, m, sum;
int cx[MAXN], cy[MAXN];
bool vis[MAXN];

bool dfs(int u) {
    vis[u] = true;
    for(int i = head[u]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(!vis[v]) {
            vis[v] = true;
            if(!cy[v] || dfs(cy[v])) {
                cx[u] = v;
                cy[v] = u;
                return true;
            }
        }
    }
    return false;
}

int hungry(int nm) {
    int ans = 0;
    for(int i = 1; i <= nm; ++i) cx[i] = cy[i] = 0;
    for(int i = 1; i <= nm; ++i) {
        for(int j = 1; j <= nm; ++j) vis[j] = false;
        if(dfs(i)) ++ans;
    }
    return ans;
}

void build() {
    sum = n+m;
    int res = hungry(sum);
    int xt = m-res, yt = n-res;
    for(int i = 1; i <= xt; ++i) {
        ++sum;
        for(int j = n+1; j <= n+m; ++j) {
            add(sum, j);
        }
    }
    for(int i = 1; i <= yt; ++i) {
        ++sum;
        for(int j = 1; j <= n; ++j) {
            add(j, sum);
        }
    }
    hungry(sum);
    for(int i = 1; i <= n+xt; ++i) add(cx[i], i);
    for(int i = n+m+1; i <= n+m+xt; ++i) add(cx[i], i);
}

int cnt, scc_cnt, t;
int dfn[MAXN], low[MAXN], sccno[MAXN], st[MAXN];

void Tarjan(int u) {
    dfn[u] = low[u] = ++cnt;
    st[++t] = u;
    vis[u] = true;
    for(int i = head[u]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(!dfn[v]) {
            Tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(vis[v]) low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u]) {
        ++scc_cnt;
        int v;
        do {
            v = st[t--];
            sccno[v] = scc_cnt;
            vis[v] = false;
        } while(v != u);
    }
}

void solve() {
    cnt = scc_cnt = t = 0;
    for(int i = 1; i <= sum; ++i) dfn[i] = vis[i] = 0;
    for(int i = 1; i <= sum; ++i) if(!dfn[i]) Tarjan(i);
    for(int i = 1; i <= n; ++i) {
        set<int> marry;
        for(int j = head[i]; j != -1; j = edge[j].next) {
            int v = edge[j].v;
            if(v > n+m) continue;
            if(sccno[i] == sccno[v]) marry.insert(v-n);
        }
        write(marry.size());
        for(set<int>::iterator j = marry.begin(); j != marry.end(); ++j) {
            putchar(' ');
            write(*j);
        }
        putchar('
');
    }
}

int main() {
    int T = read(), Case = 0;
    int nm, x;
    while(T--) {
        n = read(); m = read();
        num = 0;
        memset(head, -1, sizeof(head));    
        for(int i = 1; i <= n; ++i) {
            nm = read();
            for(int j = 0; j != nm; ++j) {
                x = read();
                add(i, x+n);
            }
        }
        printf("Case #%d:
", ++Case);
        build();
        solve();
    }
    return 0;
}

 // hdu 4738

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#define read(n) n = read_n()
#define rep(i, n) for(int i=0;i!=n;++i)
#define rep1(i, n) for(int i=1;i<=n;++i)
using namespace std;

inline int read_n() {
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
// -----------------------------------------------------
const int MAXN = 1000+5;
const int MAXM = MAXN*MAXN;
typedef pair<int,int> Pair;

int num;
int head[MAXN];
struct node {
    int v, next;
    int w;
} edge[MAXM];

inline void add(int x, int y, int w) {
    edge[num].v = y;
    edge[num].next = head[x];
    edge[num].w = w;
    head[x] = num++;
}

int n, m;
int cnt;
int dfn[MAXN], low[MAXN];
set<int> ct;
set<Pair> bb;

void Tarjan(int cur, int fa) {
    dfn[cur] = low[cur] = ++cnt;
    for(int i = head[cur]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(!dfn[v]) {
            Tarjan(v, cur);
            low[cur] = min(low[cur], low[v]);
            if(low[v] > dfn[cur] && !bb.count(make_pair(cur, v)) && !bb.count(make_pair(v, cur))) ct.insert(edge[i].w);
        }
        else if(v != fa) low[cur] = min(low[cur], dfn[v]);
    }
}

void solve() {
    cnt = 0;
    int flag = 0;
    ct.clear();
    rep1(i, n) dfn[i] = 0;
    rep1(i, n) if(!dfn[i]) ++flag, Tarjan(i, 0);
    if(flag > 1) printf("0
");
    else if(ct.empty()) printf("-1
");
    else printf("%d
", *(ct.begin()) == 0 ? 1 : *(ct.begin()));
}

int main() {
    while(scanf("%d%d", &n, &m) == 2 && n) {
        num = 0;
        rep1(i, n) head[i] = -1;
        set<Pair> b;
        bb.clear();
        int x, y, w;
        rep(i, m) {
            read(x); read(y); read(w);
            if(x > y) swap(x, y);
            Pair p = make_pair(x, y);
            if(!b.count(p)) {
                add(x, y, w);
                add(y, x, w);
                b.insert(p);
            }
            else bb.insert(p);
        }
        solve();
    }
    return 0;
}