第 194 场力扣周赛题解

气死了啊，最后一题下标打错了，发现后已经来不及了。。。。。不过内推场能打到这个名次也还行。可是真的好可惜。

5440. 数组异或操作

思路：按照题目要求直接异或就ok

class Solution {
    public int xorOperation(int n, int start) {
    	
    	int ans=0;
    	
    	for(int i=0;i<n;i++)
    		ans^=start+2*i;
    	
    	return ans;
    	
    }
}

5441. 保证文件名唯一

思路：对于每一种文件名，将名称和次数组成映射即可。

坑点：有可能一个文件名+（文件次数）构造出来的名称已经出现过，这里需要处理一下！

class Solution {
    public String[] getFolderNames(String[] names) {
    	
    	int n=names.length;
    	String[] ans=new String[n];
    	Map<String,Integer> map=new HashMap<>();
    	
    	for(int i=0;i<n;i++) {
    		String s=names[i];
    		if(map.containsKey(s)) {
    			int num=map.get(s)+1;
    			String ss=s+"("+String.valueOf(num)+")";
    			while(map.containsKey(ss)) {
    				num++;
    				ss=s+"("+String.valueOf(num)+")";
    			}
    			ans[i]=ss;
    			map.put(s, num);
    			map.put(ss, 0);
    		}
    		else {
    			ans[i]=s;
    			map.put(s, 0);
    		}
    	}
    	
    	return ans;
    
    }
}

5442. 避免洪水泛滥

PS：这道题当时卡了不少人，我过完这道题后的排名是第13。。

思路：对于每一个rains[i]大于0的位置我们是不用管的，直接无脑输出-1即可，对于rains[i]=0的位置我们需要考虑这个应该抽干哪一个湖泊，可以肯定的是如果有湖泊有产生洪水的风险，我们必须要提前抽干，但是为了保证最后尽可能的不产生洪水，我们对于每一个已经填满的湖泊，若之后他在某一天会下雨，则我们要选择当前天之后最近的一天选择去抽干该湖泊。

class Solution {
    public int[] avoidFlood(int[] rains) {
    	
    	int n=rains.length;
    	int[] ans=new int[n];
    	TreeSet<Integer> st=new TreeSet<>();
    	Map<Integer,Integer> map=new HashMap<>();
    	
    	for(int i=0;i<n;i++) {
    		if(rains[i]>0) {
    			ans[i]=-1;
    			if(map.containsKey(rains[i])) {
    				if(st.isEmpty())
    					return new int[0];
    				else {
    					Integer p=st.higher(map.get(rains[i]));
    					if(p==null) return new int[0];
    					else {
    						ans[(int)p]=rains[i];
    						st.remove(p);
    					}
    				}
    			}
    			map.put(rains[i], i);
    		}
    		else
    			st.add(i);
    	}
    	
    	Iterator<Integer> it=st.iterator();
    	while(it.hasNext())
    		ans[(int)it.next()]=1;
    	
    	return ans;
    	
    }
}

5443. 找到最小生成树里的关键边和伪关键边

思路：这道题真的好气啊，几乎是裸的最小生成树，对于关键边的判定，我们考虑枚举删除那条边会使得最小生成树的值变大；而对于伪关键边，我们在生成最小生成树前，先无脑加入该边，若产生的最小生成树的成本不改变，则这条边为伪关键边。

坑点：在关键边的判定中，删边操作可能会使得最后无法产生最小生成树，因此需要特判一下。

class Solution {
	
	private int[] f;
	private List<node> list;
	private boolean mark;
	class node implements Comparable<node>{
		int id,u,v,val;
		public node(int u,int v,int val) {
			this.u=u;
			this.v=v;
			this.val=val;
		}
		@Override
		public int compareTo(node o) {
			// TODO 自动生成的方法存根
			return val-o.val;
		}
	}
	
	public List<List<Integer>> findCriticalAndPseudoCriticalEdges(int n, int[][] edges) {

		int val=0;
		f=new int[n];
    	list=new ArrayList<>();
    	List<List<Integer>> ans=new ArrayList<>();
    	
    	for(int i=0;i<2;i++)
    		ans.add(new ArrayList<>());
    	
    	for(int i=0;i<edges.length;i++) {
    		list.add(new node(edges[i][0],edges[i][1],edges[i][2]));
    		list.add(new node(edges[i][1],edges[i][0],edges[i][2]));
    	}
    	
    	val=MST(n,-1);
    	int index=edges.length-1;
    	
    	for(int i=list.size()-1;i>0;i-=2) {
    		
    		list.remove(i);
    		list.remove(i-1);
    		mark=false;
    		int now=MST(n,-1);
    		if(val<now || mark) ans.get(0).add(index);
    		list.add(new node(edges[index][0],edges[index][1],edges[index][2]));
    		list.add(new node(edges[index][1],edges[index][0],edges[index][2]));
    		index--;
    	}
    	
    	list.clear();
    	
    	for(int i=0;i<edges.length;i++) {
    		list.add(new node(edges[i][0],edges[i][1],edges[i][2]));
    		list.add(new node(edges[i][1],edges[i][0],edges[i][2]));
    	}
    	
    	index=0;
    	
    	for(int i=0;i<list.size();i+=2) {
    		
    		if(ans.get(0).contains(index)) {
    			index++;
    			continue;
    		}

    		int now=MST(n,index);
    		if(val==now) ans.get(1).add(index);
    		index++;
    	}
    	
    	return ans;
    }
	
	private int MST(int n,int index) {
		
		index=index*2;
		
		List<node> nowList=new ArrayList<>();
		
		int size=list.size(),sum=0,num=0;
		
		int t1,t2;
		
		for(int i=0;i<size;i++)
			nowList.add(list.get(i));
		
		for(int i=0;i<n;i++) f[i]=i;
		
		if(index>=0) {
			t1=find(list.get(index).u);
			t2=find(list.get(index).v);
			if(t1!=t2) {
				num++;
				sum+=list.get(index).val;
				//System.out.println(t1+" "+t2+" "+index+" "+sum);
				f[t1]=t2;
			}
		}
		
		Collections.sort(nowList);
		
		for(int i=0;i<size;i++) {
			t1=find(nowList.get(i).u);
			t2=find(nowList.get(i).v);
			if(t1!=t2) {
				num++;
				sum+=nowList.get(i).val;
				f[t1]=t2;
			}
		}
		
		if(num<n-1) mark=true;
		
		return sum;
	}
	
	private int find(int x) {
		if(f[x]==x)
			return x;
		return f[x]=find(f[x]);
	}
}