1
2
3
unordered_map<char,int> hash;
hash.insert(pair<char,int>('A', 10));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Solution {
public:
    vector<string> findLongestSubarray(vector<string>& array) {
        int sum[100010];
        int i;
        int pre =0;
        for(i =0;i <array.size(); ++i){
            sum[i] =pre;//上一个
            if(array[i][0] >='0' && array[i][0] <='9'){//是数 +1
                sum[i] +=1;
            }else {
                sum[i] -=1;
            }
            pre =sum[i];// 记录长
        }

        //窗口l,r
        unordered_map<int, int> hash;
        hash[0] = -1; //hash[最小等势能] ==位置,记录未开始为0势能
        int l =0,r =-1,maxlen =0;
        for(i =0;i <array.size(); ++i){
            if(hash.find(sum[i]) !=hash.end()) {//找到
                int len =i -hash[sum[i]];//窗口长
                if(len >maxlen){
                    maxlen =len;
                    l =hash[sum[i]] +1;
                    r =i;//
                }
            }
            else hash[ sum[i] ] =i;// 无， 则覆盖
        }
        vector<string> ret;
        for(i =l;i <=r; ++i){
            ret.push_back( array[i] );
        }
        return ret;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class Solution {
public:
    vector<int> powerfulIntegers(int x, int y, int bound) {
        vector<int> xs, ys;
        int i,j;
        int prex =1, prey =1;
        for(i =1; prex <= bound; ++i){
            xs.push_back(prex);
            prex *=x;
            if(x ==1) {
                break;
            }
        }
        for(i =1; prey <= bound; ++i){
            ys.push_back(prey);
            prey *=y;
            if(y ==1) {
                break;
            }
        }
        
        unordered_set<int> ret;
        for(i =0;i <xs.size(); ++i){
            for(j =0;j <ys.size(); ++j){
                int val =xs[i] + ys[j];
                if(val <= bound){
                    ret.insert(val);
                }
            }
        }
        return vector<int>(ret.begin(), ret.end());
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Solution {
    int gcd(int a, int b){//最大公约数,辗转相除k
        return !b? a: gcd(b , a%b);//b=0 return a
    }
public:
    bool hasGroupsSizeX(vector<int>& deck) {
        int hash[10010];
        int n =deck.size();
        int max_num =-1;
        memset(hash , 0 ,sizeof(hash));//初始化哈希表为0
        for(int i =0; i <n; ++i){
            ++hash[ deck[i] ];//对于deck[i]分割，映射为出现次数
            max_num = max(max_num , deck[i]);//hash范围
        }
        
        int totgcd =-1;
        for(int i =0; i <=max_num; ++i){
            if(hash[i]){//有出现次数
                if(totgcd == -1){
                    totgcd = hash[i];
                }else {
                    totgcd = gcd(totgcd , hash[i]);
                }
                if(totgcd ==1) return false;
            }
        }
        return true;//最大公约数不为1
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
public:
    bool canArrange(vector<int>& arr, int k) {
        int n =arr.size();
        int hash[k +1];
        memset(hash , 0 , sizeof(hash));
        for(int i =0; i <n; ++i){
            int mod =(arr[i]%k +k) %k;//防止负数
            ++hash[ mod ];
        }
        if(hash[0] & 1) return false;//取第一位，等价除余2
        for(int i =1;i <k; ++i){
            if(hash[i] != hash[k-i]){
                return false;
            }
            if(i > (k/2 +1)){
                return true;
            }
        }
        return true;
    }
};