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
[0]=nxt
[1]=nxt
[2]=nxt
[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
[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

;
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
;
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;
}
}