刷题日记系列之4月的最后一天

• 202题。快乐数

如果一个数，比如25，循环求他的每一位的平方和。最终等于1的。为快乐数。

 

发现大的数，他的各位平方的和是变小。直到3位数。会被困在循环中。

题目则变为了检测循环。

可以用循环链表，可以用Set保存值来判断循环。

• 1395题。统计作战单位。

给定一个数组，数组的值为各兵的得分，只有当i<j<k时，a[i]<a[j]<a[k]或a[i]>a[j]>a[k]时，为有效的作战单位。

各兵可以重复使用。

求有效作战单位的个数。

 

使用动态规划。dp1[i]表示 i 索引前得分比 i 索引高的。

dp2[i] 表示 i 索引前得分比i索引低的。

res是每次找到比他小的所有的 j 让res+=dp[j]

• 432题。

使用的一个HashMap保存key-》value

一个HashMap保存value-> Node

Node 的结构是

class Node{
    int val;
    Set<String> keys;
    Node pre;
    Node next;
}

使用一个val为0 的head，val为0的tail保存结尾与开头。

head不保存数据，为了后面插入删除更方便。

这个代码很麻烦，技术不精写了一个小时，改bug改了一个小时。

加了注释的，贴在后面

class AllOne {
    HashMap<String,Integer> map;
	HashMap<Integer,LinkedNode> map2;
	LinkedNode head,tail;
    /** Initialize your data structure here. */
    public AllOne() {
        map=new HashMap<>();
    	map2=new HashMap<>();
    	head=new LinkedNode(0);
    	tail=new LinkedNode(0);
    	head.next=tail;
        tail.pre=head;
    }
    
    /** Inserts a new key <Key> with value 1. Or increments an existing key by 1. */
    public void inc(String key) {
        //不包含这个点
    	if(!map.containsKey(key)) {
    		map.put(key, 1);
    		//不是第一次添加点
    		if(map2.containsKey(1))
    			map2.get(1).keys.add(key);
    		else {//第一次添加点
    			LinkedNode newNode=new LinkedNode(1);
    			newNode.keys.add(key);
    			map2.put(1, newNode);
    			LinkedNode nextNode=head.next;
    			head.next=newNode;
    			newNode.pre=head;
    			newNode.next=nextNode;
    			nextNode.pre=newNode;
    		}
    	}//包含这个点
    	else {
    		int v=map.get(key);
    		map.put(key, v+1);
    		
    		LinkedNode now=map2.get(v);
    		LinkedNode preNode=now;
    		//如果当前值下面只有一个String，删掉整个v
    		if(now.keys.size()==1) {
    			LinkedNode p=now.pre;
    			preNode=p;
    			LinkedNode n=now.next;
    			p.next=n;
    			n.pre=p;
    			map2.remove(v);
    		}
    		else now.keys.remove(key);
    		
    		//v+1的结点
    		//包含v+1的结点
    		if(map2.containsKey(v+1)) {
    			map2.get(v+1).keys.add(key);
    		}
    		//不包含
    		else {
    			LinkedNode newNode=new LinkedNode(v+1);
        		newNode.keys.add(key);
        		LinkedNode nextNode=preNode.next;
        		preNode.next=newNode;
        		newNode.pre=preNode;
        		newNode.next=nextNode;
        		nextNode.pre=newNode;
        		map2.put(v+1, newNode);
    		}
    		
    	}
    }
    
    /** Decrements an existing key by 1. If Key's value is 1, remove it from the data structure. */
    public void dec(String key) {
        if(!map.containsKey(key))return;
    	//map直接删除
    	if(map.get(key)==1) {
    		map.remove(key);
    		LinkedNode now=map2.get(1);
    		//map2也直接删除
    		if(now.keys.size()==1) {
    			LinkedNode next=now.next;
    			head.next=next;
    			next.pre=head;
    			map2.remove(1);
    		}
    		else {
    			now.keys.remove(key);
    		}
    	}
    	//map的值--
    	else {
    		int v=map.get(key);
    		map.put(key, v-1);
    		LinkedNode now=map2.get(v);
    		LinkedNode nextNode=now;
    		if(map2.get(v).keys.size()==1) {
    			LinkedNode p=now.pre;
    			LinkedNode n=now.next;
    			nextNode=n;
    			p.next=n;
    			n.pre=p;
    			map2.remove(v);
    		}else now.keys.remove(key);
    		//接下来处理新建一个v--的结点
    		if(map2.containsKey(v-1))
    			map2.get(v-1).keys.add(key);
    		else {
    			LinkedNode newNode=new LinkedNode(v-1);
    			newNode.keys.add(key);
    			LinkedNode preNode=nextNode.pre;
    			preNode.next=newNode;
    			newNode.pre=preNode;
    			newNode.next=nextNode;
    			nextNode.pre=newNode;
    			map2.put(v-1, newNode);
    		}
    	}
    }
    
    /** Returns one of the keys with maximal value. */
    public String getMinKey() {
        if(head.next==tail)return "";
        String[] strlist=new String[head.next.keys.size()];
    	strlist=head.next.keys.toArray(strlist);
    	return strlist[0];
    }
    
    /** Returns one of the keys with Minimal value. */
    public String getMaxKey() {
        if(tail.pre==head)return "";
        String[] strlist=new String[tail.pre.keys.size()];
    	strlist=tail.pre.keys.toArray(strlist);
    	return strlist[0];
    }
    class LinkedNode{
		int val;
		Set<String> keys;
		LinkedNode pre;
		LinkedNode next;
		public LinkedNode(int val) {
			this.val = val;
			keys=new HashSet<>();
		}
		@Override
		public String toString() {
			return "LinkedNode [val=" + val + ", keys=" + keys + "]";
		}
	}
}