leetcode 685. 冗余连接 II 树拆边+并查集 分类讨论 好题

685. 冗余连接 II

在本问题中，有根树指满足以下条件的有向图。该树只有一个根节点，所有其他节点都是该根节点的后继。每一个节点只有一个父节点，除了根节点没有父节点。

输入一个有向图，该图由一个有着N个节点 (节点值不重复1, 2, …, N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。

结果图是一个以边组成的二维数组。 每一个边 的元素是一对 [u, v]，用以表示有向图中连接顶点 u 和顶点 v 的边，其中 u 是 v 的一个父节点。

返回一条能删除的边，使得剩下的图是有N个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。

示例 1:

输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的有向图如下:

  1
 / \
v   v
2-->3

示例 2:

输入: [[1,2], [2,3], [3,4], [4,1], [1,5]]
输出: [4,1]
解释: 给定的有向图如下:

5 <- 1 -> 2
     ^    |
     |    v
     4 <- 3

注意:

二维数组大小的在3到1000范围内。
二维数组中的每个整数在1到N之间，其中 N 是二维数组的大小。

---

leetcode 685. 冗余连接 II

题意 : 开始时有一颗有向树，出题人往树里加了一条边U->V，于是树就变成了图，

要我们找出这条边U->V，有多条就打印input里靠后的那条

可以发现，无论如何加边，都会生成环或至少有一个入度为2的图 (除非一个新节点指向根)

• 至少有一个入度为2，则可以枚举这两条边判断删掉是否可以构成满足题意的树
  • 判定方法：并查集内只有一个根，且生成过程中无环
• 否则构成了环，拆环内任意一条即可 (注意尽可能靠后)
• 练习函数指针

//函数指针
typedef void (*func) (vector<vector<int> >& ed, vector<int>& ans);

//生成了环 随便删一条
void slove_ind1(vector<vector<int> >& ed, vector<int>& ans) {
	for(int i=0; i<=n; i++) pre[i] = i; //并查集初始化
	for(auto it : ed) {
		int u = it[0], v = it[1];
		if(fa(u) == fa(v)) {
			ans = it;
			break;
		}
		union_xy(u, v);
	}
}

//返回删除idx后是否可以构成无环树
//若满足一下两点就返回 true
//    1. 生成树的过程不能产生环.
//    2. 并查集内只能有一个根.
bool check(vector<vector<int> >& ed, int idx) {
	bool ret = true;
	for(int i=0; i<=n; i++) pre[i] = i; //并查集初始化

	for(int i=0; i<ed.size() && ret; i++) { //生成树的过程不能产生环
		if(i == idx) continue ;
		int u = ed[i][0], v = ed[i][1];
		if(fa(u) == fa(v)) { ret = false; continue ; }
		union_xy(u, v);
	}
	int root_cnt = 0; 
	for(int i=1; i<=n; i++) //并查集内只能有一个根
		root_cnt += pre[i] == i;
    
	return (ret && root_cnt==1);
}

//最大入度为 2 
void slove_ind2(vector<vector<int> >& ed, vector<int>& ans) {
	for(int i=0; i<n; i++) {
		int u = ed[i][0], v = ed[i][1];
		if(ind[v] != 2) continue ;
		if(check(ed, i)) ans = ed[i];
	}
}

class Solution {
public:
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& ed) {
		n = ed.size();
		init();
		vector<int> ans = { -1, -1 };
		int cnt = 0, max_ind = 0;
	
		//情况一 : 构成了环 
		//情况二 : 没有构成环 (至少有一个点入度为 2 )
		for(auto it : ed) { 
			ind[it[1]] ++;
			max_ind = max(max_ind, ind[it[1]]); 
		}
		
		//练习函数指针
		func f[4] = { slove_ind1, slove_ind1, slove_ind2, slove_ind1};
		f[max_ind](ed, ans);
		return ans;
    }
};

完整代码如下

#define debug
#ifdef debug
#include <time.h>
#include "win_majiao.h"
#endif

#include <iostream>
#include <algorithm>
#include <vector>
#include <string.h>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <math.h>

#define MAXN ((int)1e5+7)
#define ll long long int
#define INF (0x7f7f7f7f)
#define fori(lef, rig) for(int i=lef; i<=rig; i++)
#define forj(lef, rig) for(int j=lef; j<=rig; j++)
#define fork(lef, rig) for(int k=lef; k<=rig; k++)
#define QAQ (0)

using namespace std;

#define show(x...) \
	do { \
	   cout << "\033[31;1m " << #x << " -> "; \
	   err(x); \
	} while (0)

void err() { cout << "\033[39;0m" << endl; }
template<typename T, typename... A>
void err(T a, A... x) { cout << a << ' '; err(x...); }

namespace FastIO{

	char print_f[105];
	void read() {}
	void print() { putchar('\n'); }

	template <typename T, typename... T2>
	   inline void read(T &x, T2 &... oth) {
		   x = 0;
		   char ch = getchar();
		   ll f = 1;
		   while (!isdigit(ch)) {
			   if (ch == '-') f *= -1; 
			   ch = getchar();
		   }
		   while (isdigit(ch)) {
			   x = x * 10 + ch - 48;
			   ch = getchar();
		   }
		   x *= f;
		   read(oth...);
	   }
	template <typename T, typename... T2>
	   inline void print(T x, T2... oth) {
		   ll p3=-1;
		   if(x<0) putchar('-'), x=-x;
		   do{
				print_f[++p3] = x%10 + 48;
		   } while(x/=10);
		   while(p3>=0) putchar(print_f[p3--]);
		   putchar(' ');
		   print(oth...);
	   }
} // namespace FastIO
using FastIO::print;
using FastIO::read;

int pre[MAXN], n, ind[MAXN];
int fa(int x) { return pre[x]==x ? x : (pre[x]=fa(pre[x])); }

void union_xy(int x, int y) {
	x = fa(x), y = fa(y);
	if(x ^ y) pre[y] = x;
}

void init() {
	for(int i=0; i<=n; i++) ind[i] = 0;
}

typedef void (*func) (vector<vector<int> >& ed, vector<int>& ans);

// 生成树构成了环 环内随便删一条
void slove_ind1(vector<vector<int> >& ed, vector<int>& ans) {
	for(int i=0; i<=n; i++) pre[i] = i; //并查集初始化
	for(auto it : ed) {
		int u = it[0], v = it[1];
		if(fa(u) == fa(v)) {
			ans = it;
			break;
		}
		union_xy(u, v);
	}
}

//返回删除idx后是否可以构成无环树
bool check(vector<vector<int> >& ed, int idx) {
	bool ret = true;
	for(int i=0; i<=n; i++) pre[i] = i; //并查集初始化

	for(int i=0; i<ed.size() && ret; i++) {
		if(i == idx) continue ;
		int u = ed[i][0], v = ed[i][1];
		if(fa(u) == fa(v)) { ret = false; continue ; }
		union_xy(u, v);
	}
	int root_cnt = 0; 
	for(int i=1; i<=n; i++)
		root_cnt += pre[i] == i;
	return (ret && root_cnt==1);
}

//最大入度为 2 
void slove_ind2(vector<vector<int> >& ed, vector<int>& ans) {
	for(int i=0; i<n; i++) {
		int u = ed[i][0], v = ed[i][1];
		if(ind[v] != 2) continue ;
		if(check(ed, i)) ans = ed[i];
	}
}

class Solution {
public:
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& ed) {
		n = ed.size();
		init();
		vector<int> ans = { -1, -1 };
		int max_ind = 0;
	
		//情况一 : 构成了环
		//情况二 : 没有构成环 (至少有一个点入度为 2 )
		for(auto it : ed) { 
			ind[it[1]] ++;
			max_ind = max(max_ind, ind[it[1]]); 
		}
		
		//练习函数指针
		func f[4] = { slove_ind1, slove_ind1, slove_ind2, slove_ind1 };
		f[max_ind](ed, ans);
		return ans;
    }
};

#ifdef debug
signed main() {
	vector<vector<int> > vec = {{1,2}, {1,3}, {2,3}};
	Solution s;
	vector<int> ans = s.findRedundantDirectedConnection(vec);
	forvec(ans);

   return 0;
}
#endif