Leetcode进阶之路——Weekly Contest 152

1175. Prime Arrangements

给定一个整数，将1~n的所有数放在a[1] ~ a[n]上，使得素数的下标也是素数，求共有多少种放置方案
求出1~n中有多少素数，假设为k个，则只要求$A_k^k\ast A_{n-k}^{n-k}$即可，即分别对素数全排列， 对非素数全排列

class Solution {
public:
	int prime(int n)
	{
		int cnt = 0;
		if (n >= 2) cnt = 1;
		for (int i = 3; i <= n; ++i)
		{
			bool flag = true;
			for (int j = 2; j <= sqrt(i) + 1; ++j)
			{
				if (i % j == 0)
				{
					flag = false;
					break;
				}
			}
			if (flag) cnt++;
		}
	}
    int numPrimeArrangements(int n) 
	{
		int MOD = 1e9 + 7;
		int cnt = prime(n);
		
		long long n1 = 1, n2 = min(cnt, n - cnt);
		for (int i = 2; i <= n2; ++i)
		{
			n1 = (n1 * i) % MOD;
		}
		n1 = (n1 * n1) % MOD;
		for (int i = n2 + 1; i <= max(cnt, n - cnt); ++i)
			n1 = (n1 * i) % MOD;
		return n1;
	}
};

1176. Diet Plan Performance

给定一个数组和三个整数，若数组中连续k个数之后小于lower，则减一分，若和大于upper，则加一分
返回最后的得分
题目描述与实际理解有出入，导致一开始一直WA，实际只要算前缀和即可

class Solution {
public:
    int dietPlanPerformance(vector<int>& calories, int k, int lower, int upper) {
        int len = calories.size(), res = 0;
        vector<int> prefix(len + 1, 0);
        for(int i = 0; i < len; ++i)
            prefix[i + 1] = prefix[i] + calories[i];
        for(int i = k; i <= len; i++)
        {
            int dif = prefix[i] - prefix[i - k];
            if(dif > upper) res++;
            else if(dif < lower) res--;
        }
        return res;
    }
};

1177. Can Make Palindrome from Substring

给定一个字符串s，和一个二维数组，数组中每个元素包含三个值，分别为[left, right, k]
判断对于s[left], s[left+1],...,s[right]的数组，重排列后，能否只替换不超过k个字符，使得其成为回文串
注意这里是可以对原字符串重排列的，如对queries[3]，提到可以先被重排列为bacd，之后替换为baab
因此这里跟上一题一样，维护一个前缀和，vv[i]表示到字符串第i位，各字符(26个)各出现了几次
最后只要出现次数为奇数的字符数小于等于2*k即可

class Solution {
public:

    vector<bool> canMakePaliQueries(string s, vector<vector<int>>& queries) {
		int len = s.length();
		vector<vector<int>> pre(len + 1, vector<int>(26, 0));
		for (int i = 0; i < s.length(); ++i)
		{
			pre[i + 1] = pre[i];
			pre[i + 1][s[i] - 'a']++;
		}
		vector<bool> res;
		for (auto q : queries)
		{
			int thres = q[2] * 2;
			if ((q[1] - q[0]) % 2 == 0) thres++;
			int flag = true;
			for (int i = 0; i < 26; ++i)
			{
				if ((pre[q[1] + 1][i] - pre[q[0]][i]) % 2)
				{
					thres--;
					if (thres < 0)
					{
						flag = false;
						break;
					}
				}
			}
			res.emplace_back(flag);
		}
		return res;
	}
};

1178. Number of Valid Words for Each Puzzle

给定两个字符串数组words，puzzles
words中的字符串word[j]为有效需要满足下面两个条件：

• puzzle[i]的首字母在word[j]中出现
• word[j]中的字符均在puzzle[i]中出现
  不需要考虑顺序问题，采用位压缩的方法，如abe, 可转化为10011,e出现过，为1，cd没出现，为0，ab出现，为1
  用一个数组存储次数，最后对每个puzzle，循环遍历判断即可

class Solution {
public:
    vector<int> findNumOfValidWords(vector<string>& words, vector<string>& puzzles) {
        vector<int> count(1<<26, 0);
        for (int i = 0; i < words.size(); i++) {
            int bit = 0;
            for (auto c: words[i]) {
                bit |= (1<<(c-'a'));
            }
            count[bit]++;
        }
        vector<int> res;
        for (int i = 0; i < puzzles.size(); i++) {
            int cnt = 0;
            for (int j = 0; j < (1<<6); j++) {
                int bit = 1<<(puzzles[i][0]-'a');
                for (int k = 0; k < 6; k++) {
                    if ((j & (1<<k)) > 0) {
                        bit |= 1<<(puzzles[i][k+1]-'a');
                    }
                }
                cnt += count[bit];
            }
            res.push_back(cnt);
        }
        return res;
    }
};