山东大学程序设计思维学习笔记作业13

A.TT的神秘任务(1)

这一天，TT 遇到了一个神秘人。

神秘人给了两个数字，分别表示 n 和 k，并要求 TT 给出 k 个奇偶性相同的正整数，使得其和等于 n。

例如 n = 10，k = 3，答案可以为 [4 2 4]。

TT 觉得这个任务太简单了，不愿意做，你能帮他完成吗？

本题是SPJ

Input
第一行一个整数 T，表示数据组数，不超过 1000。

之后 T 行，每一行给出两个正整数，分别表示 n（1 ≤ n ≤ 1e9）、k（1 ≤ k ≤ 100）。

Output
如果存在这样 k 个数字，则第一行输出 “YES”，第二行输出 k 个数字。

如果不存在，则输出 “NO”。

Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120

分析：首先判断一下一些不可能的，比如k是偶数，那n是奇数不可能，剩下的话，凡是凑奇数，则先全是减一，然后最后输出减去后的结果。偶数就是先减二

//
// Created by haofeng on 5/15/20.
//
#include 
using namespace std;
int n;int k;
int main(){
    int T;cin>>T;
    while (T--) {
        cin >> n >> k;
        if (n % 2 == 1 && k % 2 == 0) {
            cout << "NO" << endl;
        } else if (n % 2 == 0 && k % 2 == 1) {
            //全偶数
            if (n < 2 * k) {
                cout << "NO" << endl;
            } else {
                cout<<"YES"<<endl;
                for (int i = 1; i < k; ++i) {
                    cout << 2 << " ";
                    n -= 2;
                }
                cout << n << endl;
            }
        } else {
            if (n < k) {
                cout << "NO" << endl;
            } else {
                cout<<"YES"<<endl;
                for (int i = 1; i < k; ++i) {
                    cout << 1 << " ";
                    n--;
                }
                cout << n << endl;
            }
        }
    }
}

B.TT的神秘任务(2)

在你们的帮助下，TT 轻松地完成了上一个神秘任务。

但是令人没有想到的是，几天后，TT 再次遇到了那个神秘人。

而这一次，神秘人决定加大难度，并许诺 TT，如果能够完成便给他一个奖励。

任务依旧只给了两个数字，分别表示 n 和 k，不过这一次是要求 TT 给出无法被 n 整除的第 k 大的正整数。

例如 n = 3，k = 7，则前 7 个无法被 n 整除的正整数为 [1 2 4 5 7 8 10]，答案为 10。

好奇的 TT 想要知道奖励究竟是什么，你能帮帮他吗？

Input
第一行一个整数 T，表示数据组数，不超过 1000。

之后 T 行，每一行给出两个正整数，分别表示 n（2 ≤ n ≤ 1e9）、k（1 ≤ k ≤ 1e9）。

Output
对于每一组数据，输出无法被 n 整除的第 k 大的正整数。

思路：从1～n-1都是不能被n整除的，n可以，n+1～（2n-1）又是不能被整除。所以这就是个周期的问题。

//
// Created by haofeng on 5/15/20.
//
#include 
using namespace std;
int N,K,T;
int main(){
    cin>>T;
    while(T--){
        cin>>N>>K;
        int G=K/(N-1);
        int tmp=K-G*(N-1);
        if(tmp==0) {
            cout << G * N + tmp -1<< endl;
        }
        else{
            cout<<G*N+tmp<<endl;
        }
    }
}

C.TT的奖励

在大家不辞辛劳的帮助下，TT 顺利地完成了所有的神秘任务。

神秘人很高兴，决定给 TT 一个奖励，即白日做梦之捡猫咪游戏。

捡猫咪游戏是这样的，猫咪从天上往下掉，且只会掉在 [0, 10] 范围内，具体的坐标范围如下图所示。

TT 初始站在位置五上，且每秒只能在移动不超过一米的范围内接住掉落的猫咪，如果没有接住，猫咪就会跑掉。例如，在刚开始的一秒内，TT 只能接到四、五、六这三个位置其中一个位置的猫咪。

喜爱猫咪的 TT 想要接住尽可能多的猫咪，你能帮帮他吗？

Input
多组样例。每组样例输入一个 m (0 < m < 100000)，表示有 m 只猫咪。

在接下来的 m 行中，每行有两个整数 a b (0 < b < 100000)，表示在第 b 秒的时候有一只猫咪掉落在 a 点上。

注意，同一个点上同一秒可能掉落多只猫咪。m = 0 时输入结束。

Output
输出一个整数 x，表示 TT 可能接住的最多的猫咪数。

思路：又是dp问题，num[i][j]表示在j时刻掉在i位置的猫的数量。f[i][j]表示i时刻在位置j能接到的最多猫咪数，很显然在j-1时刻猫可能从两边来或本来就在这里，max(f[i-1][j-1],f[i][j-1].f[i+1][j-1])+num[i][j]

//
// Created by haofeng on 5/15/20.
//
#include 
#include 
using namespace std;
int num[100010][11];
int f[100010][11];
int M,N;
//每一步都是先移动，再接
//理解错题意了,不是接附近三个位置的猫,是这三个位置选一个
//f[i][j]表示j时刻在i位置能接到的最多
//f[i][j]=max{f[i-1][j-1],f[i][j-1],f[i+1][j-1]}
void solve() {
    for (int i = 0; i <=N ; ++i) {
        for (int j = 0; j < 11; ++j) {
            f[i][j]=-1000000;
        }
    }
    f[0][5]=0;
    for (int i = 1; i <= N; ++i) {
        f[i][0]=max(f[i-1][0],f[i-1][1])+num[i][0];
        for (int j = 1; j <10 ; ++j) {
            f[i][j]=max(f[i-1][j-1],max(f[i-1][j],f[i-1][j+1]))+num[i][j];
        }
        f[i][10]=max(f[i-1][9],f[i-1][10])+num[i][10];
    }
    int res=-9999;
    for (int i = 0; i <11 ; ++i) {
        res=max(res,f[N][i]);
    }
    cout<<res<<endl;
}
int main(){
    while (cin>>M){
        if(M==0)break;
        N=-999;
        for (int i = 0; i < 100010; ++i) {
            for (int j = 0; j <11 ; ++j) {
                num[i][j]=0;
            }
        }
        for (int i = 0; i < M; ++i) {
            int a,b;
            cin>>a>>b;
            num[b][a]++;//第b秒落在a点
            N=max(b,N);
        }
        solve();
    }
}

总结：读题是关键，开始以为是能接三个位置的猫，那样就比较麻烦了，num[i][j]要更复杂些。

D.TT的苹果树

在大家的三连助攻下，TT 一举获得了超级多的猫咪，因此决定开一间猫咖，将快乐与大家一同分享。并且在开业的那一天，为了纪念这个日子，TT 在猫咖门口种了一棵苹果树。

一年后，苹果熟了，到了该摘苹果的日子了。

已知树上共有 N 个节点，每个节点对应一个快乐值为 w[i] 的苹果，为了可持续发展，TT 要求摘了某个苹果后，不能摘它父节点处的苹果。

TT 想要令快乐值总和尽可能地大，你们能帮帮他吗？

Input
结点按 1～N 编号。

第一行为 N (1 ≤ N ≤ 6000) ，代表结点个数。

接下来 N 行分别代表每个结点上苹果的快乐值 w[i]（-128 ≤ w[i] ≤ 127)。

接下来 N-1 行，每行两个数 L K，代表 K 是 L 的一个父节点。

输入有多组，以 0 0 结束。

Output
每组数据输出一个整数，代表所选苹果快乐值总和的最大值。

思路：树形DP问题，令dp[i][1]为以i为根节点，同时选择了i节点的最大的快乐值，dp[i][0]表示以i为根节点，同时没有选择i节点的最大的，不难的到转移方程dp[i][0]=sum(max(dp[child][0],dp[child][1]),即可以选择子节点中的任何形式的最大值，dp[i][1]=sum(dp[child][0])

//
// Created by haofeng on 5/17/20.
//
#include 
#include 
#include 
using namespace std;
struct node{
    int parent;
    int weight;
    vector<int> children;
};
node Nodes[6010];
int f[6010][2];
bool cal[6010];//是否计算过f[i][0]&f[i][1]
void getF(int index){
    if(Nodes[index].children.empty()){
        f[index][0]=0;
        f[index][1]=Nodes[index].weight;
        cal[index]=true;
        return;
    }
    f[index][1]=Nodes[index].weight;
    vector<int>::iterator it=Nodes[index].children.begin();
    for (it;it!=Nodes[index].children.end();++it) {
        if(!cal[*it]){
            getF(*it);
        }
        f[index][0]+=max(f[*it][0],f[*it][1]);
        f[index][1]+=f[*it][0];
    }
    cal[index]=true;
}
void init(int n){
    //谁是根结点?==>并查集?==>向上找就行
    for (int i = 0; i <=n ; ++i) {
        f[i][0]=f[i][1]=0;
        cal[i]=false;
    }
}
int getRoot(int s){
    while (Nodes[s].parent!=-1){
        s=Nodes[s].parent;
    }
    return s;
}
int main(){
    int N;
    while(cin>>N) {
        if(N==0)break;
        int L, K;
        for (int i = 1; i <= N; ++i) {
            cin >> Nodes[i].weight;
            Nodes[i].parent=-1;
        }
        for (int i = 1; i < N; ++i) {
            cin >> L >> K;
            Nodes[K].children.push_back(L);
            Nodes[L].parent = K;
        }
        init(N);
        int root=getRoot(1);
        getF(root);
        cout<<max(f[root][0],f[root][1])<<endl;
    }
}

E.TT的神秘任务(3)
没做这题，思路：化环为线型表，拉长成原来的两倍，ppt上的套路

附：树的直径的简单证明
一个树中，定义从一个节点向另一个节点“移动”，如果移动的方向是向根节点移动，则称其为上行，如果是向叶子节点移动，称之为下行。易得不存在“平行”的情况。
从任意一个节点到其他节点，第一可以证明目标节点一定为叶子节点，否则可以继续向叶子节点移动。第二整个过程，可以分为两部分一部分是上行，另一部分是下行。也有可能没有上行，这个分类讨论。如果有上行，那么一定是上行到根节点再去找另一个叶子节点；如果没有上行，那么直接下行到它的一个叶子节点。这个最终到达的叶子节点我称之为第一目标节点。
找到它后，我们再次找离它最远的节点，仍然是上行和下行两部分，这次一定有上行，再下行到一个叶子节点，我称之为第二目标节点。接下来证明这不存在另外两个节点对比这两个更大。
如果第一目标节点是经历过上行的，那么我们可以说，除去上行的这一条路径，它是距离根节点最远的。那么在此上行找第二目标节点，是找除了当前距离根节点最远之外第二远的，d1，d2分别是最长的两条路径，不存在其他比d1+d2更大。
如果第一目标节点没经历过上行，那么说明上行+下行<单纯下行，很明显这就是距离最远的叶子节点，再去找就是第二远。
证明纯属自己想的，如果出错，请不吝赐教！