topcoder srm 435 div1

problem1 link

遍历未被删除的叶子结点即可。

problem2 link

首先，将所有的蛋白质原子编号，设为$[0,m-1]$，每个原子可能对应多个长度为3的$ACGT$。设$n$为DNA串的长度。用$g[i][j]$表示从$i$开始匹配数字$j$后的最小位置,$0\leq i \leq n-1,0\leq j \leq m-1$。

然后就是动态规划.设$dp[i][j]$表示位置$i$之前最后匹配的数字为$j$的方案数。对所有的$0\leq t < m$有$dp[g[i][t]][t]+=dp[i][j] $

problem3 link

首先将所有节点分成若干个$group$，每个$group$里的节点可以互相到达。然后一个一个$group$进行处理。

对于某个$group$，建一个新的二分图$G$。对于其中的一个点$x$，若存在不在该$group$中的一点$y$使得存在边$y$到$x$那么在新图$G$中连一条$x$到$y$的边。那么该$group$中需要作为新的$division$的根结点的个数为$|group|-maxMatch(G)$。

code for problem1

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

public class CellRemoval {

	List<List<Integer>> lists=null;

	public int cellsLeft(int[] parent, int deletedCell) {
		final int n=parent.length;
		lists=new ArrayList<>();
		for(int i=0;i<n;++i) {
			lists.add(new ArrayList<>());
		}
		int root=-1;
		for(int i=0;i<n;++i) {
			if(parent[i]==-1) {
				root=i;
			}
			else {
				lists.get(parent[i]).add(i);
			}
		}
		return dfs(root,deletedCell);
	}

	int dfs(int u,int d) {
		if(u==d) {
			return 0;
		}
		if(lists.get(u).size()==0) {
			return 1;
		}
		int result=0;
		for(int i=0;i<lists.get(u).size();++i) {
			result+=dfs(lists.get(u).get(i),d);
		}
		return result;
	}
}

　　

code for problem2

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by mcl on 2017/9/27.
 */
public class DNADeletion {

	final static int MOD=1000000007;

	public int differentProteins(String[] DNASequence, String[] codonTable) {
		StringBuilder sb=new StringBuilder();
		for(int i=0;i<DNASequence.length;++i) {
			sb.append(DNASequence[i]);
		}
		final String S=sb.toString();
		final int n=S.length();
		int[][] nxt=new int[n+1][4];
		nxt[n][0]=nxt[n][1]=nxt[n][2]=nxt[n][3]=-1;
		for(int i=n-1;i>=0;--i) {
			for(int j=0;j<4;++j) {
				nxt[i][j]=nxt[i+1][j];
			}
			nxt[i][getIndex(S.charAt(i))]=i;
		}
		List<List<String>> lists=init(codonTable);
		final int m=lists.size();
		int[][] g=new int[n][m];
		for(int i=0;i<n;++i) {
			for(int j=0;j<m;++j) {
				g[i][j]=-1;
				for(int k=0;k<lists.get(j).size();++k) {
					String s=lists.get(j).get(k);
					int cur=i;
					for(int t=0;t<s.length();++t) {
						final int id=getIndex(s.charAt(t));
						if(nxt[cur][id]==-1) {
							cur=-1;
							break;
						}
						cur=nxt[cur][id]+1;
					}
					if(cur!=-1&&(g[i][j]==-1||g[i][j]>cur)) {
						g[i][j]=cur;
					}
				}
			}
		}
		int[][] dp=new int[n+1][m];
		for(int i=0;i<m;++i) {
			if(g[0][i]!=-1) {
				dp[g[0][i]][i]=1;
			}
		}
		for(int i=0;i<n;++i) {
			for(int j=0;j<m;++j) {
				if(dp[i][j]==0) {
					continue;
				}
				for(int k=0;k<m;++k) {
					if(g[i][k]!=-1) {
						dp[g[i][k]][k]=(dp[g[i][k]][k]+dp[i][j])%MOD;
					}
				}
			}
		}
		int result=0;
		for(int i=0;i<=n;++i) {
			for(int j=0;j<m;++j) {
				result=(result+dp[i][j])%MOD;
			}
		}
		return result;
	}

	List<List<String>> init(String[] codonTable) {
		Map<String,Integer> map=new HashMap<>();
		int id=0;
		List<List<String>> lists=new ArrayList<>();
		for(int i=0;i<codonTable.length;++i) {
			String s=codonTable[i];
			String key=s.substring(0,3);
			String value=s.substring(4);
			if(!map.containsKey(value)) {
				map.put(value,id++);
				lists.add(new ArrayList<>());
			}
			lists.get(map.get(value)).add(key);
		}
		return lists;
	}

	int getIndex(char c) {
		if(c=='A') {
			return 0;
		}
		else if(c=='C') {
			return 1;
		}
		else if(c=='T') {
			return 2;
		}
		return 3;
	}
}

　　

code for problem3

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

public class CompanyRestructuring {

	public int fewestDivisions(String[] hasManaged) {
		final int n=hasManaged.length;
		boolean[][] g=new boolean[n][n];
		for(int i=0;i<n;++i) {
			for(int j=0;j<n;++j) {
				if(hasManaged[i].charAt(j)=='Y') {
					g[i][j]=true;
				}
			}
		}
		for(int k=0;k<n;++k) {
			for(int i=0;i<n;++i) {
				for(int j=0;j<n;++j) {
					if(g[i][k]&&g[k][j]) {
						g[i][j]=true;
					}
				}
			}
		}
		boolean[] visited=new boolean[n];
		int result=0;
		for(int i=0;i<n;++i) {
			if(visited[i]) {
				continue;
			}
			List<Integer> left=new ArrayList<>();
			List<Integer> right=new ArrayList<>();
			for(int j=0;j<n;++j) {
				if(i==j||g[i][j]&&g[j][i]) {
					left.add(j);
					visited[j]=true;
				}
				else {
					right.add(j);
				}
			}
			if(right.size()==0) {
				result+=left.size();
				continue;
			}
			final int lNum=left.size();
			final int rNum=right.size();
			boolean[][] graph=new boolean[lNum][rNum];
			for(int ll=0;ll<lNum;++ll) {
				for(int rr=0;rr<rNum;++rr) {
					if(hasManaged[right.get(rr)].charAt(left.get(ll))=='Y') {
						graph[ll][rr]=true;
					}
				}
			}
			result+=lNum-maxMatch(graph);
		}
		return result;
	}

	int maxMatch(boolean[][] g) {
		final int n=g.length;
		final int m=g[0].length;
		int[] match=new int[m];
		Arrays.fill(match,-1);
		int result=0;
		for(int i=0;i<n;++i) {
			if(find(i,m,g,new boolean[m],match)) {
				++result;
			}
		}
		return result;
	}
	boolean find(int u,int m,boolean[][] g,boolean[] visited,int[] match) {
		for(int i=0;i<m;++i) {
			if(!visited[i]&&g[u][i]) {
				visited[i]=true;
				int t=match[i];
				match[i]=u;
				if(t==-1||find(t,m,g,visited,match)) {
					return true;
				}
				match[i]=t;
			}
		}
		return false;
	}
}