Leetcode每日随机2021/5/4

题

哈哈今天AC了。

思

对今天的代码还是比较满意的。
第一题
这两个操作让人自然而然想到了二进制。
将0变为指定数，如果将指定数看成二进制，那么这两个操作不就是左移一位和把一个0变成1么。
所以将0变为指定数的最少操作数就是左移的次数+变1的次数。
左移的次数就是二进制串的长度-1；
变1的次数就是二进制串中1的个数；
由于左移的次数在所有数中可以复用（所有数同时左移），故只需取最大的左移次数即可；
哈哈我真聪明。
第二题
经典第二题脑瘫题
第三题
dp，其实就是一行一行加上去，第n行的结果取决于第n-1行，和其他所有行无关。
而每一行的结果就只有两种可能，左中右三个方块各不相同以及左右相同；
dp[n][0]代表以左右相同结尾的数量，dp[n][1]代表以左右不同结尾的数量；
然后就是找下规律，对于任意一个左右相同的摆法，它的下一行在12种摆法中可行的左右相同摆法有三种，可行的左右不同摆法有两种；
同理，对于任意一个左右不同的摆法，它的下一行在12种摆法中可行的左右相同摆法有两种，可行的左右不同摆法也有两种；
所以我们可以得到如下的状态转移方程：
dp[i][0] = dp[i - 1][0] * 3 + dp[i - 1][1] * 2
dp[i][1] = dp[i - 1][0] * 2 + dp[i - 1][1] * 2
当然空间是可以优化成O(1)的，忘了；

代码

第一题

class Solution {
    public int minOperations(int[] nums) {
		int addOne = 0;
		int maxMulTwo = 0;
		for (int i = 0; i < nums.length; i++) {
			int[] operations = singleMin(nums[i]);
			maxMulTwo = operations[0] > maxMulTwo ? operations[0] : maxMulTwo;
			addOne += operations[1];
		}
		return addOne + maxMulTwo;
	}

	private int[] singleMin(int num) {
		int[] temp = new int[2];
		String binary = Integer.toBinaryString(num);
		temp[0] = binary.length() - 1;
		for (int i = 0; i < binary.length(); i++) {
			if (binary.charAt(i) == '1') {
				temp[1]++;
			}
		}
		return temp;
	}
}

第二题

class Solution {

    private Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>();

	public Solution(int[] nums) {
		for (int i = 0; i < nums.length; i++) {
			if (map.containsKey(nums[i])) {
				map.get(nums[i]).add(i);
			} else {
				List<Integer> list = new ArrayList<Integer>();
				list.add(i);
				map.put(nums[i], list);
			}
		}
	}

	public int pick(int target) {
		List<Integer> list = map.get(target);
		int idx = (int) (Math.random() * list.size());
		return list.get(idx);
	}
}

/**
 * Your Solution object will be instantiated and called as such:
 * Solution obj = new Solution(nums);
 * int param_1 = obj.pick(target);
 */

第三题

class Solution {
    public int numOfWays(int n) {
		long[][] dp = new long[n + 1][2];
		dp[1][0] = 6;
		dp[1][1] = 6;
		for (int i = 2; i <= n; i++) {
			dp[i][0] = (dp[i - 1][0] * 3 + dp[i - 1][1] * 2) % 1000000007;
			dp[i][1] = (dp[i - 1][0] * 2 + dp[i - 1][1] * 2) % 1000000007;
		}
		return (int) (dp[n][0] + dp[n][1]) % 1000000007;
	}
}