牛客little白月赛43题解

 题目链接：https://ac.nowcoder.com/acm/contest/11220

总结：感觉有点难，重现赛只做对了t1，还是模拟做的，菜是原罪；

分析：t1 : 简单数学 t2 : 数学 t3 : 二进制枚举 t4:数学（全集 - 补集） t5 : DP(线性dp) t6 : 二分图

A:满意的数字

思路：第m个因子就是数本身，数mod自身自然是0，所以每一个数都是“满意的数字”；

ps：就是换个说法输出n，我做的时候竟然大模拟，真无语。。。。

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int t;
    cin >> t;

    while(t --) {
        int n;
        cin >> n;
        cout << n << endl;
    }
    
    return 0;
}

B:牛牛变魔术

思路：1.先考虑一下target是否是a， b中的一种；

           2.不满足1，为奇数，则直接输出-1；

           3.通过对满足条件的最后一次操作进行观察，只要a + b > target / 2即可一次完成，所以不停的对a+b翻倍（同时cnt ++）直到满足上个式子即可；

ps:切入点在于最后一次观察

#include <bits/stdc++.h>
#define int long long

using namespace std;

signed main()
{
    int t;
    cin >> t;
    while(t -- ) {
        int a, b, gol;
        cin >> a >> b >> gol;
        int res = 1;
        
        if(gol == a || gol == b) res = 0;
        else if(gol & 1) res = -1;
        else {
            int k = a + b;
            while(k < gol / 2) k *= 2, res ++;
        }
        cout << res << "\n";
    } 
    return 0;
}

C：木棍游戏

思路：数据非常小，直接用二进制来枚举三条边有哪些棍子组成即可；

时间复杂度：O((1 << n) ^ 3);

处理：避免方案数重复，需满足i & j == 0

海伦公式：p = (a + b + c) / 2, s = p * (p - a) * (p - b) *  (p - c);

ps：调了好久555

#include <bits/stdc++.h>

using namespace std;

int a[10], b[3];

int calc(int x) {
    int res = 0, cnt = 0;
    while(x) {
        if(x & 1)res += a[cnt];
        x >>= 1;
        cnt ++;
    }
    return res;
}

int main()
{
    int n;
    cin >> n;
    
    for(int i = 0; i < n; i ++ ) cin >> a[i];
    double ans = -1;
    for(int i = 1; i < 1 << n; i ++ ) 
        for(int j = 1; j < 1 << n; j ++ )
            if((i & j) == 0)
                for(int k = 1; k < 1 << n; k ++)
                    if((k & j) == 0 && (k & i) == 0) {
                        b[0] = calc(i), b[1] = calc(j), b[2] = calc(k);
                        sort(b, b + 3);
                        //for(int i = 0; i < 3 ; i ++ ) cout << b[i] << " ";
                        //cout << endl;
                        if(b[2] < b[0] + b[1]) {
                            double p = (b[0] + b[1] + b[2]) / 2.0;//注意是乘以2.0
                            double s =sqrt( p * (p - b[0]) * (p - b[1]) * (p - b[2]));
                            ans = max(ans, s);
                        }
                    }                            
    if(ans != -1)
    printf("%.1lf", ans);
    else cout << -1;
    return 0;
}

D：有趣的区间

思路：区间只要有一个1，取或起来必然是奇数。也就是说只要区间全为0的时候， 才不满足题意；

ans = 总区间数 - "无趣的区间数"

处理：一个区间中的子区间数可以数列求和公式推出：n * (n - 1) / 2;

ps:我竟然看成异或了，结果整了半天没整出来（无疑难度大大上升）

#include <bits/stdc++.h>
#define int long long

using namespace std;

int calc(int x) {
    return x * (x + 1) / 2;
}

signed main()
{
    int n;
    cin >> n;
    
    int sum = calc(n), cnt = 0, x;
    for(int i = 0; i < n; i ++ ) {
        cin >> x;
        if(x & 1) {
            sum -= calc(cnt);
            cnt = 0;
        }
        else cnt ++;
    }
    
    sum -= calc(cnt);
    
    cout << sum << endl;
    
    return 0;
}

E:满意的集合

引子：dp问题的优化与思考

思路:我们不妨先想一个朴素做法：如果各个数位相加是3的倍数，那么该数可以被3整除；

状态表示:f[i][j] 表示前i个数中，余数为j的集合数;ans取f[9][0];

状态转移方程：f[i][(j*i+MOD)%3] += f[i-1][MOD];

难点：这个题最难的地方在于MOD的理解，MOD其实就是上一层i中对3取余后的余数，对于本层更新来说，本层的数加上上一层的余数，就是在模3意义下的能够被3整除的集合数

for (int i=1; i<=9; i++) {
    for (int j=0; j<=cnt[i]; j++) {
        for (int MOD=0; MOD<3; MOD++) {
            f[i][(j*i+MOD)%3] = (f[i][(j*i+MOD)%3] + dp[i-1][MOD]) % mod;
        }
    }
}

时间复杂度:O(9 * n * 3) n 取e = 1e9。显然不行

优化:对状态转移方程的优化 : 优化j层----考虑到模3意义下(举例从j = 1开始，同理j = 2， j = 3)：i * 1, i * 4.... 相等，所以我们可以一次性加上sum1 = (cnt[i] + 2) / 3次的f[i - 1][MOD]);

#状态转移方程：f[i][(mod + j) % 3] += sum * f[i - 1][j];

#include <bits/stdc++.h>
#define int long long 

using namespace std;

const int mod = 1e9 + 7;

int cnt[10];

int f[10][3];

signed main()
{
    for(int i = 1; i <= 9; i ++ ) cin >> cnt[i];
    
    f[0][0] = 1;
    for(int i = 1; i <= 9; i ++ ) {
        //sum为该数位模3等于j的个数
        int sum1 = (cnt[i] + 2) / 3, sum2 = (cnt[i] + 1) / 3, sum3 = cnt[i] / 3 + 1;
        int mod1 = i % 3, mod2 = (2 * i) % 3, mod3 = (3 * i) % 3;
        for(int j = 0; j < 3; j ++ ) {
            f[i][(mod1 + j) % 3] = (f[i][(mod1 + j) % 3] + sum1 * f[i - 1][j]) % mod;
            f[i][(mod2 + j) % 3] = (f[i][(mod2 + j) % 3] + sum2 * f[i - 1][j]) % mod;
            f[i][(mod3 + j) % 3] = (f[i][(mod3 + j) % 3] + sum3 * f[i - 1][j]) % mod;            
        }
    }
    
    cout << f[9][0];
    
    return 0;
}

ps:此次比赛的最难题，十分有难度

F:全体集合

思路:1.判断一下是否有奇数环，如果有的话，两个人之间的距离(隔着几条边)必定能够通过这个环变为偶数，进而满足题意；

2.无环则判断两个人之间的距离是否是偶数(只判断从一个人到其他人的距离即可)

处理：1.判断是否有奇数环，其实就是判断是否不为二分图(有奇数环则不为二分图)，用染色法轻松解决

           2.两人之间的距离是否为偶数，可以通过起点（随便选定一个）来判断是否为同一染色;

#include <bits/stdc++.h>
#define int long long

using namespace std;

const int N = 1e6 + 10;

vector<int> g[N];
int spot[N];
int color[N];

bool dfs(int u, int c) {
    color[u] = c;
    
    for(int i : g[u]) {
        if(!color[i]) {
            if(!dfs(i, 3 - c)) return false;
        }
        else if(color[i] != 3 - c) return false;
    }
    
    return true;
}

signed main()
{
    int n, m, k;
    cin >> n >> m >> k;
    
    for(int i = 0; i < m; i ++ ){
        int a, b;
        cin >> a >> b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    
    for(int i = 1; i <= k; i ++ ) cin >> spot[i];
    
    if(!dfs(1, 1)) {
        puts("YES");
        return 0;
    }
    
    int c = color[spot[1]];//草
    for(int i = 2; i <= k; i ++ )
        if(color[spot[i]] != c)//颜色不统一说明该点到其他点的距离为奇数，不可以满足题意
        {
            puts("NO");
            return 0;
        }
        puts("YES"); 
        
    return 0;
}

ps1:如果压根就不是连通图的话，在判断染色是否统一的时候，会因为color[spot[i]]  != 0而输出NO（此点未染色）

ps2:int c = color[spot[1]];这段我写成int c = spot[1];直接debug了一个小时