202312 CSP认证

1. 仓库规划
直接写的一个暴力搜索，一一做匹配就好

在这里插入代码片#include<bits/stdc++.h>
using namespace std;
const int N = 1010, M = 13;
int decode[N][M];
int n, m;
//比较J是不是I的上级部门
bool compare(int i, int j)
{
    bool ans = true;
    for(int k = 0;k < m;k ++){
        if(decode[i][k] >= decode[j][k]){
            ans = false;
            return ans;
        }
    }
    return ans;
}
int main()
{
    cin >> n >> m;
    for(int i = 1;i <= n;i ++){
        for(int j = 0;j < m;j ++){
            cin >> decode[i][j];
        }
    }
    for(int i = 1;i <= n;i ++){
        bool flag = false;
        for(int j = 1;j <= n;j ++){
            flag = compare(i, j);
            if(flag){
                cout << j << endl;
                break;
            }
        }
        if(!flag)
            cout << 0 << endl; //为物流中心

    }
    return 0;
}

2. 因子化解
写的时间不短，大体的思路大概正确，有两个难点和错误点
第一个：补充了一个指定数内（N）求所有质数的一个算法——埃拉托斯特尼筛法
原理简单，从2开始迭代，找到每个质数，然后将当前质数的所有倍数的数字都标记为不是质数，直至找到N以内的所有质数
第二个：ans的顺序
最开始的想法是将初始值设为n本身，有未满足重要因子的部分就除掉；但这个带来一个问题，若最后不为1，而是大于100000的，到底是应该保留还是应该置为1（可能存在大于100000的质数==>应该置为1 和 应该保留的部分），此时加剧判断的复杂性
最后的最后发现可以改变思路，改除为乘。也即将初始值置为1， 若满足重要性就乘上。此时无需考虑大于100000的部分，因为 k > 1，此时大于100000的因子不可能保留

在补充有埃拉托斯特尼筛法代码后再自写（每次第二题能写但是耗时不短…）

#include<bits/stdc++.h>
using namespace std;
long long n;
int k, q;
vector<int> primes;
//这是一个功能函数，用来高效的计算小于或等于N的所有质数
//时间复杂度 n * log(log n))
void compute_prime(int n)
{
    vector<bool> prime(n + 1, true);  //用来记录每个数字是否为质数
    prime[0] = prime[1] = false;

    for(int i = 2;i * i <= n;i ++){
        if(prime[i]){
            //删除该质数的所有倍数
            for(int j = i * i; j <= n; j += i){  //为什么是i * i =>如果合理的话，所有含有 i-1 因子的数都已经被标记，所以包含因子i的最小数字是i*i
                prime[j] = false;
            }
        }
    }

    //放入质数
    for(int i = 2;i <= n;i ++){
        if(prime[i]){
            primes.push_back(i);
        }
    }

}
int main()
{
    compute_prime(100000);  //最大数为10^(10)
    int q;
    cin >> q;
    while(q --) {
        cin >> n >> k;
        long long ans = 1;
        for(int i = 0;i < primes.size() && n > 1;i ++){
            int cnt = 0;
            while(n % primes[i] == 0){
                n /= primes[i];
                cnt ++;
            }
            if(cnt >= k)
                ans *= pow(primes[i], cnt);
        }
        cout << ans << endl;
    }
    return 0;
}

3. 树上搜索
自写20分版本，查阅了关于set这个容器的部分操作（集合的减法）
运行超时

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2010;
int n, m;
ll w[N];
ll weight[N];   //记录每个节点的初始权重
int pre[N];   //记录每个类别的上级类别
map<int, set<int> > type_tree;  //记录每个类别的所有后代类别

int main()
{
    cin >> n >> m;
    ll sum_all = 0;
    for(int i = 1;i <= n;i ++){
        cin >> weight[i];
        sum_all += weight[i];
    }

    pre[1] = 0;
    for(int i = 2;i <= n;i ++){
        type_tree[1].insert(i);

        scanf("%d", &pre[i]);
        int x = pre[i];
        while(x != 1){
            type_tree[x].insert(i);
            x = pre[x];
        }
    }
    while(m --){
        int query;
        scanf("%d", &query);  //输入查询内容

        map<int, set<int> > child_node = type_tree;
        set<int> ans;
        ll s = sum_all;

        for(int i = 1;i <= n;i ++){
            ans.insert(i);  //开始点集为全集
        }

        while(ans.size() != 1){
            int Min = s, index;

            //对于现有的每一个类别
            for(set<int>::iterator node = ans.begin(); node != ans.end(); node ++){
                //计算当前节点(*node)的全部后代权重之和
                set<int> child = child_node[*node];
                ll sum = weight[*node];
                for(set<int>::iterator it = child.begin(); it != child.end(); it ++){
                    sum += weight[*it];
                }
                w[*node] = abs(s - 2 * sum);

                if(w[*node] < Min){
                    Min = w[*node];
                    index = *node;
                    if(w[*node] == 0)
                        break;
                }
            }
            cout << index <<" ";

            //此时Index就是需要询问的类别
            if(query == index || child_node[index].count(query)){
                //只保留index及其后代类别
                ans = child_node[index];
                ans.insert(index);

                s = 0;
                for(set<int>::iterator node = ans.begin(); node != ans.end(); node ++){
                    s += weight[*node];
                }

            }else{
                //删除index及其所有后代类别
                set<int> child = child_node[index];
                child.insert(index);

                //做集合的减法
                set<int> tmp;
                set_difference(ans.begin(), ans.end(), child.begin(), child.end(), insert_iterator<set<int> >(tmp, tmp.begin()));
                ans = tmp;

                //更新sum_all
                for(set<int>::iterator it = child.begin(); it != child.end(); it ++){
                    s -= weight[*it];
                }

                //删除后代类别中的index及其后代
                int x = pre[index];
                while(x != 0){
                    for(set<int>::iterator it = child.begin(); it != child.end(); it ++){
                        child_node[x].erase(*it);
                    }
                    x = pre[x];
                }
            }

        }
        cout << endl;
    }
    return 0;
}