LeetCode525. 连续数组 / 牛客：雀魂启动！

525. 连续数组

2021.6.3 每日一题，昨天下了一天雨

题目描述

给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。
 

示例 1:

输入: nums = [0,1]
输出: 2
说明: [0, 1] 是具有相同数量0和1的最长连续子数组。
示例 2:

输入: nums = [0,1,0]
输出: 2
说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/contiguous-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

超时了，而且只过了34个用例就超时了，感觉有点问题

class Solution {
    public int findMaxLength(int[] nums) {
        //两层循环会超时，所以只能想一层
        //能够得到什么条件，能够得到，目前有几个1和几个0
        int n = nums.length;
        //存储几个1和当前下标
        int count = 0;
        //因为这里有count个1时，对应的下标可能有多个
        Map<Integer, List<Integer>> map = new HashMap<>();
        List<Integer> list0 = new ArrayList<>();
        list0.add(-1);
        map.put(0, list0);
        int max = 0;
        for(int i = 0; i < n; i++){
            if(nums[i] == 1){
                count++;
            }
            //当前有count个1，有i - count + 1个0，所以在哈希表中从小到大找0 ~ count - 1 个1，设为t个
            //此时区间里就有count - t 个1，那么对应的0也应该有count - t 个，即此时的下标应该对应的是x满足，i - x = (2count-2t)
            //x = i - (2count-2t)
            for(int t = 0; t < count; t++){
                List<Integer> list = map.get(t);
                int id = i - 2 * count + 2 * t;
                //如果找到了一个区间符合条件
                if(list.contains(id)){
                    int len = i - id;
                    max = Math.max(max, len);
                    break;
                }
            }
            //如果存在当前count，直接存入哈希表
            if(map.containsKey(count)){
                map.get(count).add(i);
            }else{
                List<Integer> list = new ArrayList<>();
                list.add(i);
                map.put(count, list);
            }
        }
        return max;
 
    }
}

去看了题解，发现将0看成 -1 以后，这个题就转换成了和为k的子数组，然后还是前缀和加哈希表…继续加油吧

class Solution {
    public int findMaxLength(int[] nums) {
        //还是前缀和加哈希表
        int n = nums.length;
        //将0看成-1，然后遍历，哈希表存储当前值和最小出现的下标
        Map<Integer, Integer> map = new HashMap<>();
        int cur = 0;
        int max = 0;
        map.put(0, -1);
        for(int i = 0; i < n; i++){
            if(nums[i] == 1)
                cur++;
            else
                cur--;
            if(map.containsKey(cur))
                max = Math.max(max, i - map.get(cur));
            else
                map.put(cur, i);
        }
        return max;
    }
}

雀魂启动！

题目描述

链接：https://www.nowcoder.com/questionTerminal/448127caa21e462f9c9755589a8f2416
来源：牛客网

小包最近迷上了一款叫做雀魂的麻将游戏，但是这个游戏规则太复杂，小包玩了几个月了还是输多赢少。
于是生气的小包根据游戏简化了一下规则发明了一种新的麻将，只留下一种花色，并且去除了一些特殊和牌方式（例如七对子等），具体的规则如下：

总共有36张牌，每张牌是1~9。每个数字4张牌。
你手里有其中的14张牌，如果这14张牌满足如下条件，即算作和牌
14张牌中有2张相同数字的牌，称为雀头。
除去上述2张牌，剩下12张牌可以组成4个顺子或刻子。顺子的意思是递增的连续3个数字牌（例如234,567等），刻子的意思是相同数字的3个数字牌（例如111,777）

例如：
1 1 1 2 2 2 6 6 6 7 7 7 9 9 可以组成1,2,6,7的4个刻子和9的雀头，可以和牌
1 1 1 1 2 2 3 3 5 6 7 7 8 9 用1做雀头，组123,123,567,789的四个顺子，可以和牌
1 1 1 2 2 2 3 3 3 5 6 7 7 9 无论用1 2 3 7哪个做雀头，都无法组成和牌的条件。

现在，小包从36张牌中抽取了13张牌，他想知道在剩下的23张牌中，再取一张牌，取到哪几种数字牌可以和牌。

输入描述:
输入只有一行，包含13个数字，用空格分隔，每个数字在1~9之间，数据保证同种数字最多出现4次。


输出描述:
输出同样是一行，包含1个或以上的数字。代表他再取到哪些牌可以和牌。若满足条件的有多种牌，请按从小到大的顺序输出。若没有满足条件的牌，请输出一个数字0
示例1
输入
1 1 1 2 2 2 5 5 5 6 6 6 9
输出
9
说明
可以组成1,2,6,7的4个刻子和9的雀头

示例2
输入
1 1 1 1 2 2 3 3 5 6 7 8 9
输出
4 7
说明
用1做雀头，组123,123,567或456,789的四个顺子

示例3
输入
1 1 1 2 2 2 3 3 3 5 7 7 9
输出
0
说明
来任何牌都无法和牌

思路

我的思路是这样，首先统计所给数组中每个数字的个数，总共13个数，然后遍历1-9，添加到这个数组中，一共就是14个数字，然后判断这14个数字是否可以和牌
受到题目所给示例的启发，先挑出雀头，也就是大于两个的数定为雀头
然后判断剩下12个数字是否能组成4个符合要求的组

从左到右遍历这12个数，如果有大于3张的，那么就先挑出3张，组成1组；然后如果该数 i 个数小于等于两个，就只能和后面的数i + 1和 i + 2组成顺子，如果后面的数没有，就返回false；如果最后能组成4个组，就返回true

写了小一个小时，但是这难度还是两颗星！！！！
代码实现如下：

import java.util.*;

public class Main{
    public static void main(String[] args){
        int[] nums = new int[13];
        Scanner sc = new Scanner(System.in);
        for(int i = 0; i < 13; i++){
            nums[i] = sc.nextInt();
        }
        int[] count = new int[10];
        for(int i = 0; i < 13; i++){
            count[nums[i]]++;
        }
        List<Integer> res = new ArrayList<>();
        //主要问题还是如何判断和牌
        for(int i = 1; i <= 9; i++){
            //如果已经有4个了就跳过
            if(count[i] == 4)
                continue;
            count[i]++;
            //当前14张牌，判断是否和牌
            if(judge(count))
                res.add(i);
            //最后减回去
            count[i]--;
        }
        for(int t : res){
            System.out.print(t + " ");
        }
    }
    
    public static boolean judge(int[] count){
        //先找雀头
        for(int i = 1; i <= 9; i++){
            if(count[i] >= 2){
                count[i] -= 2;
                if(help(count)){
                    count[i] += 2;
                    return true;
                }
                count[i] += 2;
            }
        }
        return false;
    }
    //12张牌判断是否是4组
    public static boolean help(int[] count){
        //先找单个的
        int[] temp =  Arrays.copyOfRange(count, 0, 10);
        int t = 0;
        for(int i = 1; i <= 9; i++){
            if(temp[i] < 0)
                return false;
            if(temp[i] >= 3){
                temp[i] -= 3;
                t += 3;
            }
            //找到第一个不是0也不是3个的，那想要和牌，必须和后面的组成顺子
            if(temp[i] > 0 && temp[i] <= 2){              
                int k = temp[i];
                if(i + 2 > 9)
                    continue;
                if(k == 1){
                    temp[i]--;
                    temp[i + 1]--;
                    temp[i + 2]--;
                    t += 3;
                }else{
                    temp[i] -= 2;
                    temp[i + 1] -= 2;
                    temp[i + 2] -= 2;
                    t += 6;
                } 
            }
        }
        return t == 12;
    }
}