Codeforces 987 K预处理BFS 3n,7n+1随机结论题/不动点逆序对 X&Y=0连边DFS求连通块数目...

最新推荐文章于 2020-11-04 13:19:14 发布
最新推荐文章于 2020-11-04 13:19:14 发布
阅读量156 收藏
点赞数
原文链接：http://www.cnblogs.com/Aragaki/p/9110472.html
版权

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 int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = 55 + 5;
int n, K;
ll sum[N][N];
ll a[N];
bool dp[N][N];
map<string, int> mp2;
map<int, string> mp;
int visit[10];
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        mp2["purple"] = 1;
        mp2["green"] = 2;
        mp2["blue"] = 3;
        mp2["orange"] = 4;
        mp2["red"] = 5;
        mp2["yellow"] = 6;
        mp[1] = "Power";
        mp[2] = "Time";
        mp[3] = "Space";
        mp[4] = "Soul";
        mp[5] = "Reality";
        mp[6] = "Mind";
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
                string now;
                cin >> now;
                visit[mp2[now]]++;
        }
        cout << 6 - n << endl;
        for (int i = 1; i <= 6; i++)
        {
                if (!visit[i])
                {
                        cout << mp[i] << endl;
                }
        }
        return 0;
}
View Code

B

/*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 int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = 55 + 5;
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        ll x, y;
        cin >> x >> y;
        if (x == y || x == 2 && y == 4 || x == 4 && y == 2)
        {
                cout << "=" << endl;
                return 0;
        }
        if (x == 1 || y == 1)
        {
                if (x == 1)
                {
                        cout << "<" << endl;
                }
                else
                {
                        cout << ">" << endl;
                }
                return 0;
        }
        if (max(x, y) <= 10)
        {
                ll ansx = 1;
                for (int i = 1; i <= y; i++)
                {
                        ansx *= x;
                }
                ll ansy = 1;
                for (int i = 1; i <= x; i++)
                {
                        ansy *= y;
                }
                if (ansx > ansy)
                {
                        cout << ">" << endl;
                }
                else
                {
                        cout << "<" << endl;
                }
                return 0;
        }
        if (x > y)
        {
                cout << "<" << endl;
        }
        else
        {
                cout << ">" << endl;
        }
        return 0;
}
View Code

C

/*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 int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = 55 + 5;
int num[3005];
ll cost[3005];
ll dp[3005][4];
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
                cin >> num[i];
        }
        for (int i = 1; i <= 3000; i++)
        {
                for (int j = 1; j <= 3; j++)
                {
                        dp[i][j] = LLONG_MAX;
                }
        }
        for (int i = 1; i <= n; i++)
        {
                cin >> cost[i];
                dp[i][1] = cost[i];
        }
        for (int i = 2; i <= n; i++)
        {
                for (int j = i - 1; j >= 1; j--)
                {
                        for (int k = 2; k <= 3; k++)
                        {
                                if (dp[j][k - 1] != LLONG_MAX&&num[i]>num[j])
                                {
                                        dp[i][k] = min(cost[i] + dp[j][k - 1], dp[i][k]);
                                }
                        }
                }
        }
        ll anser = LLONG_MAX;
        for (int i = 1; i <= n; i++)
        {
                anser = min(anser, dp[i][3]);
        }
        if (anser == LLONG_MAX)
        {
                cout << -1 << endl;
        }
        else
        {
                cout << anser << endl;
        }
        return 0;
}
View Code

D. Fair

题意:

给你N个点M条边的连通图(100000) 和K个特殊地方(100) S个目标地(100)

每个特殊的地方有某种特产 问你从1到N每个点要拿S个特产的最少的花费

解:

给每个特产都建一个超级点 然后BFS 处理出1到N每个点到每种特产的最小距离

然后贪心取前S个即可 复杂度nklogk

/*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 int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = 1e5 + 105;
int p[N];
vector<int> g[N];
int ans[N];
int dist[N];
int que[N];
int dp[N][105];
int getl, getr;
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        int n, m, k, s;
        cin >> n >> m >> k >> s;
        for (int i = 1; i <= n; i++)
        {
                cin >> p[i];
        }
        int u, v;
        for (int i = 1; i <= m; i++)
        {
                cin >> u >> v;
                g[u].pb(v);
                g[v].pb(u);
        }
        for (int i = 1; i <= k; i++)
        {
                getl = 1;
                getr = 0;
                mem(dist, 0);
                for (int j = 1; j <= n; j++)
                {
                        if (p[j] == i)
                        {
                                dist[j] = 1;
                                que[++getr] = j;
                        }
                }
                while (getl <= getr)
                {
                        int len = g[que[getl]].size();
                        for (int w = 0; w < len; w++)
                        {
                                int to = g[que[getl]][w];
                                if (!dist[to])
                                {
                                        dist[to] = dist[que[getl]] + 1;
                                        que[++getr] = to;
                                }
                        }
                        getl++;
                }
                for (int j = 1; j <= n; j++)
                {
                        dp[j][i] = dist[j] - 1;
                }
        }
        for (int i = 1; i <= n; i++)
        {
                sort(dp[i] + 1, dp[i] + 1 + k);
        }
        for (int i = 1; i <= n; i++)
        {
                for (int j = 1; j <= s; j++)
                {
                        ans[i] += dp[i][j];
                }
        }
        for (int i = 1; i <= n; i++)
        {
                cout << ans[i] << " ";
        }
        cout << endl;
        return 0;
}
View Code

E. Petr and Permutations

题意:

给你1到N的一种排列 A会选3n次每次随机一对位置交换 B会选7n+1次

问你给你的数列是A得到的可能性大还是B的可能性大

①:

可以猜到结论 观察可以得知3n和7n+1的奇偶性永远是不同的

所以我们计算原数列所需要的最小交换次数 当这个次数与A奇偶性相同就是A 反之则是B

(因为要与原数列相同的话在最小交换次数基础上要加偶数次)

/*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 int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = 1e6 + 105;
int par[N], hs[N];
int sz[N];
int num[N];
int cnt;
void init(int n)
{
        for (int i = 0; i <= n; i++)
        {
                par[i] = i, hs[i] = i, sz[i] = 1;
        }
}
int find(int x)
{
        return par[x] == x ? x : par[x] = find(par[x]);
}
void unite(int x, int y)
{
        x = find(x);
        y = find(y);
        if (x != y)
        {
                par[x] = y, sz[y] += sz[x];
        }
}
int visit[N];
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        int n;
        cin >> n;
        init(n);
        for (int i = 1; i <= n; i++)
        {
                cin >> num[i];
        }
        for (int i = 1; i <= n; i++)
        {
                if (num[i] != i)
                {
                        unite(i, num[i]);
                }
        }
        for (int i = 1; i <= n; i++)
        {
                par[i] = find(i);
        }
        ll anser = 0;
        for (int i = 1; i <= n; i++)
        {
                if (!visit[par[i]])
                {
                        anser += sz[par[i]] - 1;
                        visit[par[i]] = 1;
                }
        }
        //cout << anser << endl;
        if (anser % 2 == 3 * n % 2)
        {
                cout << "Petr" << endl;
        }
        else
        {
                cout << "Um_nik" << endl;
        }
        return 0;
}
View Code

②:

也可以用不动点+逆序对分情况处理

当n不小于20000时 考察不动点的数量  n小于20000时取逆序对的数量判断奇偶性

int main()
{
    int i,j,a1,a2;
    _(n);
    fo(i,n)
        _(a[i]);
    fo(i,n)
        an+=(a[i]==i);
    if(n>=20000)
        puts(an>=20?"Petr":"Um_nik");
    else
    {
        fo(i,n)            
        fo1(j,i+1,n)
            if(a[j]<a[i])
                ans++;
        puts((ans+n)%2?"Um_nik":"Petr");
    }
}
View Code

F. AND Graph

题意:

给你0 - 2n-1范围中的m个数 (n<=22)

如果两个数字Ai Aj 两个&的值为0 则这两个点之间有一条边 问你最后的连通块有几个

解:

暴力题.. 假设有X,Y两个数 X的二进制恰好是Y的基础上多出一位1  比如 101 与 001 我们称X为Y的祖先 Y是X的子孙

这样能与祖先X相连的点 肯定能和Y相连 这样X,Y其实就通过对立数间接相连

所以我们每次DFS一个数的时候 把X全部子孙找出来 也把所有对立数(包括子孙的)找出来 他们肯定就是一个连通块

因为N最大是22 所以我们可以直接暴力循环枚举 开两个bool 数组 num[i]为true表示i是被选中的数 而vis[i]为true表示i被DFS过了

/*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 int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = (1 << 22) + 5;
int n, m, now;
int anser;
bool num[N], vis[N];
void dfs(int x)
{
        if (vis[x])  //如果之前已经DFS到过
        {
                return ;
        }
        vis[x] = true;
        for (int i = 0; i < n; i++)
                if (x & (1 << i))  //DFS每个二进制比X少一位1的数保证main循环中不会被循环到
                {
                        dfs(x ^ (1 << i));
                }
        if (num[x])  //如果X是存在的 找所有X对立面的数
        {
                dfs((1 << n) - 1 - x);
        }
}
int main()
{
        cin >> n >> m;
        for (int i = 1; i <= m; i++)
        {
                scanf("%d", &now);
                num[now] = true;
        }
        for (int i = (1 << n) - 1; i >= 0; i--)
                if (!vis[i] && num[i])  //如果有存在的数且没有被DFS到
                {
                        anser++;  //连通块答案数+1
                        dfs((1 << n) - 1 - i); //DFS全部与i连通的数
                }
        cout << anser << endl;
        return 0;
}
View Code

 

转载于:https://www.cnblogs.com/Aragaki/p/9110472.html

baichuan9723
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Codeforces Daily (Round 370-410)
Roll_Keyboard的博客
04-11 343
—————————————————————————- 时间:8.1 &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;am
RatingBeforeRounds_1：Codeforces竞赛的用户评分为500 <= id <= 1000
02-18
标题“RatingBeforeRounds_1：Codeforces竞赛的用户评分为500 <= id <= 1000”指的是一个数据集或者项目，它聚焦于Codeforces平台上的编程竞赛。Codeforces是一个全球知名的在线编程竞赛平台，它吸引了众多...
Codeforces 987C 题解
FrozenAllen的博客
06-08 556
题意：给定两个长度为 n 的序列，要求在第一个序列 a 里，找到一个严格递增的子序列，要求 i &lt; j &lt; k 且 a[i] &lt; a[j] &lt; a[k]，问你找到的这三个位置i , j , k，在第二个序列 b 里所对应的 b[i] + b[j] + b[k]，的最小值是多少。思路：先n^2处理出来每个元素 a[i] 后面比 a[i] 大的 a[j] 所对应的 b[j] 的...
Codeforces987 E. Petr and Permutations（思维+逆序对）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
11-04 147
题意： 一开始有一个长度为n的原排列a， 一次操作随机选择两个不同位置的数a(i)和a(j)，然后交换。 Petr会进行3n次操作，Alex会进行7n+1次操作。 现在给出结果序列，要求判断结果序列是经过谁的操作得到的。 数据范围：1e3<=n<=1e6 ...
codeforces 987E Petr and Permutations（结论+逆序对）
Stupid_Turtle的博客
05-30 951
传送门题意：Petr和Alex两个人对一个初始为1,2,3,...,n的长度为n的排列有不同的操作次数（一次操作表现为将其中两个数交换位置，比如1,2,3,4变为1,2,4,3称为一次操作），Petr会对其进行3n次操作，而Alex会对其进行7n+1次操作。现在给你初始排列的长度n和结果排列，问你是他们中的谁进行的操作，如果是Petr输出"Petr"，否则输出"Um_nik"。思路：利用到排列的性...
CodeForces ~ 987E ~ Petr and Permutations （思维，有趣）
张松超的博客
05-31 356
题意：有n个数字，原始序列为1~n，给你该序列经过Petr或Um_nik操作后序列，问你是谁操作的？Petr：随机交换两个数的位置，交换3n次。Um_nik： 随机交换两个数的位置，交换7n+1次。思路：可以发现3n和7n+1一定是一奇一偶的，那么我看考虑这个序列跟操作次数奇偶的性质，然后我就想不出来啦，哈哈哈。第二天看了别人的题解才会。考虑两个数字的时候我们交换 2x 次跟没交换一样，交换2x+...
codeforces987E(想法？)
雪霜贸贸，荠麦之茂
05-30 375
题意：给出一个1到n的序列，Petr打乱了3n次，Um_nik打乱了7n+1次，现你有打乱后的数列，求是谁打乱的。 分析：比赛的时候怕是失了智在那边想随机算法…事实上用选择排序，找出最少交换次数，然后判断奇偶性就可以了…… for(int i=1;i&amp;lt;=n;i++){ cin&amp;gt;&amp;gt;now[i];//目前所占i这个位置的数字 pos[n...
【长更】一句话题解（组队训练的俄罗斯题、oj、camp）
热门推荐
Four's
04-15 2万+
还是太长了，第二次分裂。。
Codeforces Round #629 (Div. 3) E – Tree Queries dfs序判祖先关系
01-20
这里，st[x]和ed[x]分别表示节点x的DFS访问起始和结束时间戳，而st[y]和ed[y]是节点y的相应时间戳。如果所有节点都在同一条链上，它们的时间戳应当是相互包含的。如果有任何节点不满足这个条件，即min(ed[]) > max...
Codeforces 每日一练 268C+1132F+1251D
01-03
构造水题了，很明显每行/列最多放一个，那么最多应该放min(n,m)+1个，由于0,0不能选，直接从左上角走一个对角线即可。 #include #define IOS std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); using ...
ACM/NOI/CSP比赛经验分享&代码程序资源
06-23
1. **基础打牢**: - 掌握数据结构（如链表、栈、队列、树、图）和算法（如排序、查找、动态规划）的基础知识。 2. **语言选择**: - 熟悉至少一种竞赛支持的编程语言（如C++、Java、Python），了解其语法和特性。 ...
RatingBeforeRounds_0：ID为<= 500的Codeforces竞赛的用户评分
02-18
RatingAfterRounds_0 ID <= 500的Codeforces竞赛的用户评分
开题报告达达宠物认领信息网站的设计与实现 已通过开题答辩的.docx
07-25
宠物认领信息网站的主要目的是为寻找宠物的失主和寻找新家的宠物提供一个在线的信息交流平台。通过这个平台，失主可以发布失宠信息，寻找走失或遗弃的宠物；而救助人或组织则可以发布待领养的宠物信息，为那些无家可归的宠物寻找一个永久的归宿。 这样的网站通常会提供一个详细的宠物数据库，包括照片、品种、年龄、健康状况等信息，以便让失主能够方便地找到自己的宠物。同时，网站还会提供一些相关的服务，如失主与救助人之间的在线交流、宠物匹配推荐、领养手续办理等，以帮助双方顺利完成宠物的认领和领养过程。 宠物认领信息网站的目的在于提高失宠找到宠物的几率，减少流浪宠物的数量，并为那些无家可归的宠物提供一个温馨的新家。同时，网站还能促进社会对流浪宠物的关注和保护，提高人们的动物保护意识。
开题报告创权法律服务系统 已通过开题答辩的.doc
07-25
进入20世纪80年代，我国加快了改革开放的步伐，市场经济体制已逐步形成，我国的经济发展受世人所瞩目，但法律法规的置后，使经济发展不规范问题暴露的相当严重，特别是社会整体信用的缺失，使消费环境不断恶化。而如今随着城镇化的高速推进，精神追求远不及物质发展迅速，维权问题也越来越成为人们十分关注的社会话题。 维权是指维护个人或群体的合法权益，范围包括人身损害、土地纠纷、 医疗事故、婚姻、家庭、继承等民事纠纷所进行的行政及司法诉讼。维护消费者合法权益关系着全社会每个人的利益，群众利益无小事。维护消费者合法权益正体现着“权为民所用，利为民所谋”。而现如今由于法律规则的不完善加上自身对法律知识的不了解，导致很多公民的权益问题在复杂的社会情况下无法得到妥善的解决，使得公民的财产和心理受到难以弥补的损失，严重威胁到社会的安全与稳定，公民之间的诚信与统一。因此更便捷、迅速地维护公民的合法权益，已经成为了一个刻不容缓去解决的社会问题。
Matlab实现豪猪优化算法CPO-TCN-Multihead-Attention多输入单输出回归预测算法研究.rar
最新发布
07-25
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
人力资源-6 团结一致共创未来新员工座谈会.pptx
07-25
人力资源-6 团结一致共创未来新员工座谈会.pptx
《AI大模型应用》--基于PepperBot，可以保留上下文的LLM群聊机器人实现.zip
07-25
上接OpenAI、文心一言，下接QQ、微信、Telegram 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！
开题报告传统糕点 已通过开题答辩的.docx
07-25
理论意义： 1、网页设计是信息传播的重要手段，通过合理的布局、图文搭配等设计元素，可以更好地传递传统糕点的信息。理论上，这涉及到传播学、信息传递模型等方面的理论研究，确保信息能够被受众准确、清晰地接收。 2、用户体验理论强调用户与网页之间的交互和感知。在传统糕点推广网页设计中，理论上的考虑应该包括用户友好的界面、易于导航的网站结构，以及引导用户深入了解传统糕点的设计元素。
codeforces round #792 (div. 1 + div. 2)
06-06
codeforces round #792 (div. 1 + div. 2) 是 Codeforces 竞赛平台上的一场比赛，包括两个级别：div. 1 和 div. 2。这场比赛通常会有多个问题需要参赛者解决，每个问题都有不同的难度等级。参赛者需要在规定的时间内...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值