Codeforces 980 并查集/模拟贪心最小字典序 找规律/数去除完全平方因子 逆思维倍增预处理祖先标记点

A

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll LLmaxn = 2e18;
int main()
{
        string a;
        cin >> a;
        int b=, c=;
        for (int i = ; i < a.size(); i++)
        {
                if (a[i] == '-')
                {
                        b++;
                }
                else
                {
                        c++;
                }
        }
        //cout<<b<<" "<<c<<endl;
        if (c == )
        {
                cout << "YES" << endl;
                return ;
        }
        if (b % c != )
        {
                cout << "NO" << endl;
        }
        else
        {
                cout << "YES" << endl;
        }
        return ;
}

B

解:

注意只要是上下对称或者是左右对称就可以使得 1-4 有一条路径的话 2-3 也有相对应的一条路径

剩下的就容易构造了

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll LLmaxn = 2e18;
char ans[][];
int main()
{
        int n, k;
        cin >> n >> k;
        for (int i = ; i <= ; i++)
        {
                for (int j = ; j <= n; j++)
                {
                        ans[i][j] = '.';
                }
        }
        int sum = (n - ) * ;
        if (k > sum)
        {
                cout << "NO" << endl;
                return ;
        }
        cout << "YES" << endl;
        if (k %  == )
        {
                int cur = k;
                for (int j = ; j <= n -  && cur; j++)
                {
                        for (int i = ; i <=  && cur; i++)
                        {
                                ans[i][j] = '#';
                                cur--;
                        }
                }
        }
        else
        {
                k--;
                ans[][n /  + ] = '#';
                for (int i = ; i <=  && k; i++)
                {
                        for (int j = ; j <= n /  && k; j++)
                        {
                                ans[i][j] = ans[i][n - j + ] = '#';
                                k -= ;
                        }
                }
        }
        for (int i = ; i <= ; i++)
        {
                for (int j = ; j <= n; j++)
                {
                        cout << ans[i][j];
                }
                cout << endl;
        }
        return ;
}

C

解:

可以用并查集维护每个点最小到达的地方 也因为N<=1E5,K<=256 直接暴力模拟也可以

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll LLmaxn = 2e18;
char ans[][];
int main()
{
        int n, k;
        cin >> n >> k;
        for (int i = ; i <= ; i++)
        {
                for (int j = ; j <= n; j++)
                {
                        ans[i][j] = '.';
                }
        }
        int sum = (n - ) * ;
        if (k > sum)
        {
                cout << "NO" << endl;
                return ;
        }
        cout << "YES" << endl;
        if (k %  == )
        {
                int cur = k;
                for (int j = ; j <= n -  && cur; j++)
                {
                        for (int i = ; i <=  && cur; i++)
                        {
                                ans[i][j] = '#';
                                cur--;
                        }
                }
        }
        else
        {
                k--;
                ans[][n /  + ] = '#';
                for (int i = ; i <=  && k; i++)
                {
                        for (int j = ; j <= n /  && k; j++)
                        {
                                ans[i][j] = ans[i][n - j + ] = '#';
                                k -= ;
                        }
                }
        }
        for (int i = ; i <= ; i++)
        {
                for (int j = ; j <= n; j++)
                {
                        cout << ans[i][j];
                }
                cout << endl;
        }
        return ;
}

D

卡题意...

给出一个数组,把里面的数字分组,使得每一个组里面的数两两相乘都是完全平方数.

问最少可以分成的组数k是多少.

现在一个人有一个数组,他想知道这个数组的连续子数组中,使得上面的问题答案分别为1到n的数组有多少个.

第一种做法:

注意当一个数X的因数有完全平方数Y的时候 把这个数替换为X/Y并不影响结果

当一个数是0的时候要特判 要因为0乘任何数都是0可以加入任意一组

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <set>
#include <math.h>
using namespace std;
const int N = ;
int a[N];
int b[N];
int c[N];
bool vis[N];
int mabs(int x)
{
    return x >=  ? x : -x;
}
int main()
{
    int n;
    int cnt = ;
    scanf("%d",&n);
    for (int i = ;i < n;i++)
    {
        scanf("%d",&a[i]);
        if (a[i] != ) cnt++;
    }
    if (cnt == )
    {
        printf("%d ",n * (n + ) / );
        for (int i = ;i < n;i++) printf("0 ");
    }
    else
    {
        for (int i = ;i < n;i++)
        {
            if (a[i] == ) continue;
            int tmp = mabs(a[i]);
            for (int j = ;j * j <= tmp;j++)
            {
                int t = j * j;
                while (a[i] % t == )
                {
                    a[i] /= t;
                }
                //if (a[i] < t) break;加了这个就wa，卡了一晚上，考虑的应该是绝对值的情况
            }
        }
        for (int i = ;i < n;i++) c[i] = a[i];
        sort(c,c+n);
        int js = unique(c,c+n) - c;
        for (int i = ;i < n;i++)
        {
            if (a[i] == ) continue;
            int p = lower_bound(c,c+js,a[i]) - c + ;
            a[i] = p;
        }
        for (int i = ;i < n;i++)
        {
            memset(vis,,sizeof(vis));
            int num = ;
            for (int j = i;j < n;j++)
            {
                if (!vis[a[j]] && a[j] != )
                {
                    num++;
                    vis[a[j]] = ;
                }
                int tt = max(num,);
                b[tt]++;
            }
        }
        for (int i = ;i <= n;i++)
        {
            printf("%d ",b[i]);
        }
    }
    return ;
}

第二种做法:

可以证明当A*B为完全平方数B*C也为完全平方数时 A*C也是完全平方数

所以只要N^2遍历 用并查集维护每个数属于哪个集合就行 注意0可以属于任意一个集合

#include<bits/stdc++.h>
using namespace std;
const int N = ;
long long a[N];
int ans[N], fa[N], d[N];
int bz[N];
int n, sum, tot;
bool check(long long x)
{
        if (x < )
        {
                return ;
        }
        long long y = sqrt(x);
        return y * y == x || (y - ) * (y - ) == x || (y + ) * (y + ) == x;
}
int main()
{
        ios::sync_with_stdio(false);
        cin >> n;
        for (int i = ; i <= n; i++)
        {
                fa[i] = i;
        }
        for (int i = ; i <= n; i++)
        {
                cin >> a[i];
                if (a[i])
                {
                        for (int j = ; j <= d[]; j++)
                                if (check(a[i]*a[d[j]]))
                                {
                                        fa[i] = d[j];
                                        break;
                                }
                        if (fa[i] == i)
                        {
                                d[++d[]] = i;
                        }
                }
        }
        for (int i = ; i <= n; i++)
        {
                sum = ;
                tot++;
                for (int j = i; j <= n; j++)
                {
                        if (a[j] && bz[fa[j]] != tot)
                        {
                                bz[fa[j]] = tot, sum++;
                        }
                        ans[max(sum, )]++;
                }
        }
        for (int i = ; i <= n; i++)
        {
                cout << ans[i] << ' ';
        }
        return ;
}

E

给你N个点 组成的一颗树 分别从1标号到N 每个点的粉丝数量为2^i个

要求是选择K个点删除 使得剩下没被删的点保持连通且剩下的粉丝数量最大

一旦某个点被删除则其不能通过且该点的粉丝数量清零

假如做法顺着做 找出需要删除那些点的话 因为要保证连通性所以删除一个点需要删除掉他所有子树的点 不好做

题目提示你K<N 所以点N是一定可以保留的 就以N为根倍增预处理祖先 倒着做 找出不需要删除的点即可

/* Huyyt */
#include <bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define mkp(a,b) make_pair(a,b)
#define pb push_back
using namespace std;
typedef long long ll;
const long long mod = 1e9 + ;
const int N = 1e6 + ;
inline int readint()
{
        char c = getchar();
        int ans = ;
        while (c < '' || c > '')
        {
                c = getchar();
        }
        while (c >= '' && c <= '')
        {
                ans = ans *  + c - '', c = getchar();
        }
        return ans;
}
vector<int> tree[N];
bool check[N];
int father[N][];
int deep[N];
void dfs(int x, int level)
{
        for (int i = ; father[father[x][i]][i]; i++)
        {
                father[x][i + ] = father[father[x][i]][i];
        }
        deep[x] = level;
        for (int i = ; i < tree[x].size(); i++)
        {
                int to = tree[x][i];
                if (to == father[x][])
                {
                        continue;
                }
                father[to][] = x;
                dfs(to, level + );
        }
}
int main()
{
        int n, k;
        n = readint(), k = readint();
        //cout << n << " " << k << endl;
        int u, v;
        for (int i = ; i < n; i++)
        {
                u = readint(),v = readint();
                tree[u].pb(v);
                tree[v].pb(u);
        }
        k = n - k;
        k--, check[n] = ;
        dfs(n, );
        for (int i = n - ; i >=  && k; i--)
        {
                int aim = -;
                int now = i;
                if (check[i])
                {
                        continue;
                }
                for (int j = ; j >= ; j--)
                {
                        if (father[now][j] ==  || check[father[now][j]])
                        {
                                continue;
                        }
                        now = father[now][j];
                }
                if (deep[i] - deep[now] +  <= k)
                {
                        now = i;
                        while (now !=  && !check[now])
                        {
                                check[now] = ;
                                k--;
                                now = father[now][];
                        }
                }
        }
        for (int i = ; i <= n - ; i++)
        {
                if (!check[i])
                {
                        cout << i << " ";
                }
        }
        return ;
}