【牛客小白月赛23】 A【二进制枚举+bitset】B【数学】 C【二分】 E G【思维】 H【模拟】 I J

A

思路：一开始，可能有点蒙，居然直接暴力求，其实稍微计算一下，就可以发现暴力时间上是过不去的。后面想到了bitset，但是其count()函数的时间复杂度还是不确定，比赛时没敢写，赛后尝试了一发，过了。呵呵。
Code：

#include 
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 11;
const int M = 1e6 + 11;
const int MOD = 1e9 + 7;

char s[N];
bitset<N>mp[20];
int main(int argc, char **args){
    int T; scanf("%d", &T);
    while(T--){
        int n, m, a, b; scanf("%d%d%d%d", &n, &m, &a, &b);
        for(int i = 0; i < n; i++) {
            scanf("%s", s);
            mp[i].reset();
            for(int j = 0; s[j]; j++){
                if(s[j] == '*' ) mp[i].set(j);
            }
        }
        bool flag = false;
        for(int row = 0; row < (1 << n); row ++){ // 二进制枚举所有的行选可能
            if(__builtin_popcount(row) != a) continue;
             
            bitset<N>s; s.reset(); 
            for(int r = 0; r < n; r++){
                if( !(row >> r & 1)) {
                    s |= mp[r];
                }
            } 
      
            if(s.count() <= b) {
                flag = true; break;
            }
        }
        puts(flag ? "yes" :"no");
    }
return 0;
}

B

思路：从算数基本定理考虑就行了。先获取p的质因子和其指数，然后我们只要找到一个数n，其阶乘包含这些质因子（指数上也要超过），就可以了。赛时没有想到二分这个n，其实就应该二分枚举n的。当时想法是，如果很大的n阶乘都无法整除p的话，那么一定是p里面包含了某个很大的质数，因为是质数，所以至少要是这个质数的阶乘才可以整除它。
Code：

#include 
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 11;
const int M = 1e6 + 11;
const int MOD = 1e9 + 7;

ll p[30], ge, c[30];
void getn(ll n){ // 得到n的质因子以及相应次数
    ge=0;
    for(ll i = 2; i * i <= n; i++){
        if(n % i == 0) p[ge++] = i, c[ge - 1] = 0;
        while(n % i == 0) {
            n /= i; c[ge - 1]++;
        }
    }
    if(n > 1) p[ge++] = n, c[ge - 1] = 1;
}
int get_n(int n, int p) {  //n！的质因子p的指数
    int sum = 0;  
    while (n) {   n /= p;  sum += n; }   
    return sum;  
} 
int main(int argc, char **args){
    int T; scanf("%d", &T);
    while(T--){
        int pp; scanf("%d", &pp);
        getn(pp);
        int i;
        for( i = 1; i < 1000; i++){
            int flag = 1;
            for(int j = 0; j < ge; j++){
                if(get_n(i, p[j]) < c[j]) {
                    flag = false; break;
                }
            }
            if(flag) break;
        }
        if(i == 1000){
            ll mx = 0;
            for(int i = 0; i < ge; i++) mx = max(mx, p[i]); // 找到最大的质数
            printf("%lld\n", mx);
        }
        else printf("%d\n", i);
    }
return 0;
}

C

思路：应该很容易想到，想要这个连通分量多，假设最后有k+1个分量，则一定消耗了n - 1 + n - 2 + n - 3 … n - k = k * n - (k + 1) * k / 2 个边，只要让其小于m就好了。这里可以看出当k <= n，是单调的，所以二分枚举即可。还有一个问题，在应用这个公式的时候，是会爆LL的，所以这里可以选择换个编程语言（python最方便），或者用_int128来解决。

E

思路：没什么说的。

#include 
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 11;
const int M = 1e6 + 11;
const int MOD = 1e9 + 7;

int main(int argc, char **args){
    ll n = 4294967296;
    cout << n <<"\n";
return 0;
}

G

思路：因为每条边都有一个颜色，且不重复，如果我们要能够计算出，每条边要计算多少次，然后贪心一下，排个序就ok了。
Code：

#include 
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 11;
const int M = 1e6 + 11;
const int MOD = 1e9 + 7;

vector<pii>ve[N];
int n;
ll cnt[N], son[N];
void dfs(int u, int fa){
    son[u] = 1;
    for(int i = 0; i < ve[u].size(); i++){
        pii t = ve[u][i];
        int v = t.first;
        if(v == fa) continue;
        dfs(v, u);
        cnt[t.second] = son[v] * (n - son[v]);  // 计算当前边需要的次数
        son[u] += son[v];
    }
}
int main(int argc, char **args){
    scanf("%d", &n);
    int m = n - 1;
    for(int i = 1; i <= m; i++){
        int a,  b; scanf("%d%d", &a, &b);
        ve[a].push_back(pii(b, i));
        ve[b].push_back(pii(a, i));
    }
    dfs(1, -1);
    sort(cnt + 1, cnt + 1 + m);
    ll ans = 0;
    for(int i = 1; i <= m; i++){
        ans += cnt[i] * 1ll * (m - i + 1);
    } 
    cout << ans  <<"\n";
return 0;
}

H

思路：模拟就好，从 第29位开始，当前位需要多少，我们就用多少就可以了，如果当前位不够，说明需要后面位来凑，以此类推。
Code：

#include 
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 11;
const int M = 1e6 + 11;
const int MOD = 1e9 + 7;
 
vector<int>ve[30];
char ans[N];
int main(int argc, char **args){
    int T; scanf("%d", &T);
    while(T--){
        int n; scanf("%d", &n); 
        for(int i = 0; i < 30; i++){
            ve[i].clear();
        }

        for(int i = 1; i <= n; i++){
            int k; scanf("%d", &k);
            ve[k].push_back(i);
        }

        for(int i = 1; i <= n; i++) ans[i] = '0';
        int cha = 2; int i; 
        for(i = 29; i >= 0; i--){
            for(int j = 1; j <= cha && j <= ve[i].size(); j++){
                ans[ve[i][j - 1]] = '1';
            }
            if(ve[i].size() >= cha)  break;
            cha -= ve[i].size(); cha *= 2;  // 往下一阶的时候，要乘2
        }
        if(i < 0) puts("impossible");
        else {
            ans[n + 1] = '\0';
            puts(ans + 1);
        }
    }
return 0;
}

I

思路：暴力存储所有的子串，然后排个序就行了。
Code：

#include 
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 11;
const int M = 1e6 + 11;
const int MOD = 1e9 + 7;

int main(int argc, char **args){
    string s; cin >> s;
    vector<string>ve;
    for(int i = 0; i  < s.size(); i++){
        for(int j = 1; i + j - 1 < s.size(); j++){
            ve.push_back(s.substr(i, j));
        }
    }    
    sort(ve.begin(), ve.end());
    cout << ve[ve.size() - 1] <<"\n";
    return 0;
}

J

Code：

#include 
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 11;
const int M = 1e6 + 11;
const int MOD = 1e9 + 7;

int a[N];
int main(int argc, char **args){
    int n; cin >>n;
    for(int i = 0 ; i< n; i++){
        scanf("%d", a + i);
    }
    sort(a, a + n);
    cout << a [n - 1] - a[0] <<"\n";
return 0;
}