22下第五周周赛总结

Acwing

第二题：整数拆分

思路：该题涉及到哥德巴赫猜想，虽然还未能证明，但已经实践在"较小范围数"中的正确性。

/*
哥德巴赫猜想
质数为1  大于等于6的合数为2  奇合数   若其可以分解为一奇一偶两个质数 其他偶质数一定是2  所以 判断n-2 是质数还是合数
n-2是质数答案为2 n-2是合数答案>=3

简单来说 n为质数答案为1 n为偶数答案为2 n为奇合数 分解为一奇一偶两个数
若两个都是质数 则偶质数一定是2 所以判断 n-2是否为奇数 n-2为奇数 答案为2
n-2为偶数 则分解为n-3 和 3  n-3为偶数 所以 答案为3
*/

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

bool check(int x)
{
    for(int i=2;i<=x/i;i++){
        if(x%i==0) return false;
    }
    return true;
}

int main()
{
    int n;
    cin >> n;
    if(check(n)){
        cout << 1;
    }
    else if(n%2==0||check(n-2)) cout << 2;
    else cout << 3;
    return 0;
}

第三题：买糖果

思路：暴力，代码段注释为什么暴力可以过

/*
该题以为暴力做法不能通过
但实际上可以过
因为如果sum>T/2  T%sum=T-sum<T/2
如果sum<=T/2   T%sum<sum<=T/2  
发现每循环一轮 T就会减半 所以时间复杂度为O(nlogT)
*/

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;

const int N = 200010;

int n;
LL T;
int w[N];

int main()
{
    scanf("%d%lld", &n, &T);
    for (int i = 0; i < n; i ++ ) scanf("%d", &w[i]);

    LL res = 0;
    while (true)
    {
        LL cnt = 0, sum = 0;
        for (int i = 0; i < n; i ++ )
            if (sum + w[i] <= T) //能买就买 不能买就下一家
            {
                sum += w[i];
                cnt ++ ;
            }

        if (!sum) break; //买不了任何东西退出

        res += T / sum * cnt;
        T %= sum;
    }

    printf("%lld\n", res);
    return 0;
}

LeetCode

单周赛第三题：最小XOR

思路：先得到x的置位数，然后和nums1的置位数比较，分情况讨论即可，有1就去抵消nums1的高位，多出来的1从低位往高位为0的位中填。

class Solution {
public:
    int tmp[35]={0};
    int minimizeXor(int nums1, int nums2) {
        int cnt=0;
        int ans=0;
        while(nums2){
            nums2&=(nums2-1);
            cnt++;
        }
        int cnt1=0;
        for(int i=0;i<32;i++){
            if(nums1>>i&1){
                cnt1++;
                tmp[i]=1;
            }
        }
        if(cnt==cnt1){
            ans=nums1;
        }
        else if(cnt<cnt1){
            int t=0;
            for(int i=31;i>=0;i--){
                if(!cnt) break; 
                if(nums1>>i&1){
                    cnt--;
                    ans+=1<<i;
                } 
            }
        }
        else{
            ans=nums1;
            int cnt2=cnt-cnt1;
            for(int i=0;i<32;i++){
                if(!cnt2) break;
                if(!(ans>>i&1)){
                    cnt2--;
                    ans+=1<<i;
                }
            }
        }
        
        return ans;
    }
};

单周赛第四题：对字符串可执行的最大删除数

思路：动态规划 f[i]表示删除子串i~n所需要的最大操作次数，因为要前缀相等才能删除，所以不妨从后往前做dp，并使用字符串哈希快速找出匹配字符串

typedef unsigned long long ULL;
const int N=4010,P=131;
ULL h[N],p[N]; //溢出自动取模

class Solution {
public:
    ULL get(int l,int r) //左右区间
    {
        return h[r]-h[l-1]*p[r-l+1]; //把字符串转化为数字 哈希
    }

    int deleteString(string s) {
        int n=s.size();
        p[0]=1;
        for(int i=1;i<=n;i++){
            p[i]=p[i-1]*P;
            h[i]=h[i-1]*P+s[i-1];
        }

        vector<int> f(n+1);
        for(int i=n;i>0;i--){
            f[i]=1; //最坏情况是清空 需要一次操作
            for(int j=1;j<=(n-i+1)/2;j++){ //j为长度
                if(get(i,i+j-1)==get(i+j,i+j*2-1)){
                    f[i]=max(f[i],f[i+j]+1); //和前缀相等才转换
                }
            }
        }
        return f[1]; //比较时间复杂度为O(1)  状态转移时间复杂度为O(n^2)  总时间复杂度为O(n^2) 
    }
};

双周赛第一题：删除字符使频率相同

思路：边界条件很坑，就分类讨论

1. 如果字符出现的频率种数大于两种，无论怎么操作都无法使相同，abbccc
2. 如果字符出现频率种数只有一种，此时如果字符串由单字母组成，则可以相同，例如aaa；若字符串由多字母组成，则判断它们的频率是否是1，如果是，则满足，例如abcdef。
3. 如果频率种数是两种，如果较小频率只出现过一次，并且满足该频率为1，则满足，例如abbcc；较大频率只出现过一次并且满足较大频率与较小频率只差为1，则满足，例如aabbccc。

#define x first
#define y second

class Solution {
public:
    bool equalFrequency(string word) {
        set<char> S;
        vector<int> cnt(26);
        for (auto c: word) 
            cnt[c - 'a'] ++ , S.insert(c);

        map<int, int> h;
        for (int i = 0; i < 26; i ++ ) 
            if (cnt[i])
                h[cnt[i]] ++ ;

        if (h.size() > 2) return false;
        if (h.size() == 1) return h.begin()->x == 1 || S.size() == 1; //频率为1 或只由一种字母组成
        auto r = h.end(); r -- ; //map有序
        auto l = h.begin();
        return (r->y == 1 && r->x - l->x == 1 || l->y == 1 && l->x == 1); //较大频率出现一次 且与较小频率差值为1    或  较小频率出现一次 且频率为1
    }
};

双周赛第三题：所有数对的异或和

思路：展开相同相削，设n=nums1.size()，m=nums2.size()，则可以分类讨论

1. 若n与m都是偶数，直接返回0
2. 若n为偶数但m为奇数，则返回nums1的异或和
3. 若n为奇数但m为偶数，则返回nums2的异或和
4. 若n为奇数但m为奇数，则返回nums1的异或和与nums2的异或和的异或值

class Solution {
public:
    int xorAllNums(vector<int>& nums1, vector<int>& nums2) {
        int n=nums1.size();
        int m=nums2.size();
        vector<int> cnt1(32);
        vector<int> cnt2(32);
        for(int i=0;i<m;i++){
            for(int j=0;j<32;j++){
                if(nums2[i]>>j&1) cnt1[j]++;
                else cnt2[j]++;
            }
        }
        int res=0;
        if(n%2==0&&m%2==1){
            int tmp=0;
            for(int i=0;i<n;i++){
                tmp^=nums1[i];
            }
            return tmp;
        }
        if(n%2==0&&m%2==0) return 0;
        if(n%2==1&&m%2==0){
            int tmp=0;
            for(int i=0;i<m;i++){
                tmp^=nums2[i];
            }
            return tmp;
        }
        if(n%2==1&&m%2==1){
            int tmp=0;
            for(int i=0;i<n;i++) tmp^=nums1[i];
            for(int j=0;j<m;j++) tmp^=nums2[j];
            return tmp;
        }
        return res;
    }
};

双周赛第四题： 满足不等式的数对数目

思路：树状数组

typedef long long LL;

const int N = 100010, M = 30010;

class Solution {
public:
    int tr[N];

    int lowbit(int x) {
        return x & -x;
    }

    void add(int x, int v) {
        for (int i = x; i < N; i += lowbit(i)) tr[i] += v;
    }

    int sum(int x) {
        int res = 0;
        for (int i = x; i; i -= lowbit(i)) res += tr[i];
        return res;
    }

    LL numberOfPairs(vector<int>& a, vector<int>& b, int d) {
        int n = a.size();
        vector<int> c(n);
        for (int i = 0; i < n; i ++ ) c[i] = a[i] - b[i] + M;

        LL res = 0;
        for (auto x: c) {
            res += sum(x + d);
            add(x, 1);
        }

        return res;
    }
};