F. 程序设计：寻找重复项
用map存一下出现过得，模拟一下，找到出现了的直接return，记得要把最开始的1也记录一下。
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<bitset>
#include<vector>
#include<queue>
#include<stack>
#include<map>
using namespace std;
const int maxn = 2e6 + 100;
const int inf=0x3f3f3f3f;
typedef long long ll;
ll gcd(ll x, ll y) { return y == 0 ? x : gcd(y, x % y); }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
map<ll, ll> mmp;
ll a, b, c, f[maxn];
int main()
{
cin >> a >> b >> c;
f[0] = 1;
mmp[1]=1;
for (int i = 1; i <= 2000000;i++)
{
f[i] = (a * f[i - 1] + f[i - 1] % b) % c;
if(mmp[f[i]]==1)
{
cout << i << endl;
//system("pause");
return 0;
}
mmp[f[i]] = 1;
}
cout << -1 << endl;
//system("pause");
return 0;
}
H. 程序设计：字符串
有一个长度为 LL 的字符串，每个字符是大写字母。如果我们把 AA 看做 00 ，BB 看做 11 ，CC 看做 22 … ZZ 看做 2525，那么我们就得到了一个 2626 进制的数字串。
我们可以对这个字符串做一个操作：将两个位置的字母进行交换。这样得到了一个新的数字串。
现在有一个十进制整数 MM ，请判断是否可以通过做至多一次（可以不做）操作，使得得到的字符串是 MM 的倍数。
输入格式
第一行一个只包含大写字母的字符串。
第二行一个整数 MM 。
输出格式
如果初始串就可以，那么输出 “0 0”（不加引号）
如果通过一次操作可以，请输出交换的两个位置的标号（标号小的在前，从 11 开始）。如果有多解，输出字典序最小的。
如果做不到，那么输出 “-1 -1”（不加引号）
数据范围
字符串长度为 LL 。
对于 30%30% 的数据： 1 \leq L \leq 10, 1 \leq M \leq 1001≤L≤10,1≤M≤100
对于 50%50% 的数据：除前面 30%30% 外， 1 \leq L \leq 500, M = 51≤L≤500,M=5 或 2525 或 2626
对于 100%100% 的数据： 1 \leq L \leq 2, 000, 1 \leq M \leq 200,0001≤L≤2,000,1≤M≤200,000
样例输入复制
NETTLE
35
样例输出复制
1 2
样例解释
交换 N 和第一个 E 。
刚开始做就想着暴力，枚举每两个交换过得，看了一下数据，字符串长度2000，int 128也不够爆的，神题，这个题的正解应该是先把字符串最开始表示值多m取模的结果求出来，然后再算出字符串每个位置上代表权值是多少，然后n^2暴力枚举交换，交换过程怎么算这个数改变多少呢
for (int i = 0; i < str.size();i++)
for (int j = i + 1; j < str.size();j++)
{
ll temp = (((str[j] - 'A') - (str[i] - 'A')) * v[i] + ((str[i] - 'A') - (str[j] - 'A')) * v[j]) % m;
if((temp+sum)%m==0)
{
cout << i + 1 << " " << j + 1 << endl;
//system("pause");
return 0;
}
}
如下，把两个数位上的数交换后变化多少乘这个数位上的权值，然后相加，再加上之前求出来的字符串多m取模后的数，此时就是交换后的数，然后判断即可。
代码：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<bitset>
#include<vector>
#include<queue>
#include<stack>
#include<map>
using namespace std;
const int maxn = 1e4 + 100;
const int inf=0x3f3f3f3f;
typedef long long ll;
typedef pair<int, int> pii;
ll gcd(ll x, ll y) { return y == 0 ? x : gcd(y, x % y); }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll sum, w[maxn];
int v[maxn];
int main()
{
string str;
int m;
cin >> str >> m;
for (int i = 0; i < str.size();i++)
{
sum = (sum * 26 + str[i] - 'A') % m;
}
v[str.size()-1] = 1;
for(int i=str.size()-2; i>=0; i--)
v[i] = (v[i+1]*26)%m;
if(!sum||!m)
{
cout << 0 << " " << 0 << endl;
return 0;
}
for (int i = 0; i < str.size();i++)
for (int j = i + 1; j < str.size();j++)
{
ll temp = (((str[j] - 'A') - (str[i] - 'A')) * v[i] + ((str[i] - 'A') - (str[j] - 'A')) * v[j]) % m;
if((temp+sum)%m==0)
{
cout << i + 1 << " " << j + 1 << endl;
//system("pause");
return 0;
}
}
cout << "-1 -1" << endl;
//system("pause");
return 0;
}
I. 程序设计：最短路
给定一个 n 点 m 边的有向带权图表示一座城市，起点为 1 。送餐小哥需要给 n 个客户送外卖，第 i个客户的家在第 i号点。由于他的车子容量很小，所以一次只能容纳一份外卖，所以送达外卖之后就要回到起点取新的外卖送下一单，直到全部送到位置。
有向图保证联通。外卖小哥一定走的最短路。
求送餐小哥走的总路程。
输入格式
第一行一个整数 TT，表示数据组数。
对于每组数据，第一行两个整数 n 和 m 。
接下来 m 行，每行三个整数 ui,vi,ci
表示每条有向边。
输出格式
对于每组数据，输出一行一个整数表示答案。
保证答案在 long long 范围内。
样例输入
2
2 2
1 2 13
2 1 33
4 6
1 2 10
2 1 60
1 3 20
3 4 10
2 4 5
4 1 50
样例输出
46
210
正向建图在反向建图，各自跑一遍spfa，求1到个点的距离。
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<bitset>
#include<vector>
#include<queue>
#include<stack>
#include<map>
using namespace std;
const int maxn = 1e6 + 100;
const int inf=0x3f3f3f3f;
typedef long long ll;
ll gcd(ll x, ll y) { return y == 0 ? x : gcd(y, x % y); }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll n, m, tol, head[maxn], dis[maxn], vis[maxn], head1[maxn];
struct node
{
int to, cost,next;
}rode[maxn];
struct node1
{
int to, cost,next;
}edge[maxn];
void add(ll a,ll b,ll c){
rode[tol].to=b;
rode[tol].cost=c;
rode[tol].next=head[a];
head[a]=tol++;
}
void add1(ll a,ll b,ll c){
edge[tol].to=b;
edge[tol].cost=c;
edge[tol].next=head1[a];
head1[a]=tol++;
}
void spfa1(int s){
queue<int>q;
memset(dis, inf, sizeof dis);
dis[s]=0;
vis[s]=1;
q.push(s);
while(!q.empty()){
int v=q.front();
q.pop();
vis[v]=0;
for(int i=head1[v];i!=-1;i=edge[i].next)
{
node1 e=edge[i];
if(dis[e.to]>dis[v]+e.cost)
{
dis[e.to]=dis[v]+e.cost;
if(!vis[e.to])
{
q.push(e.to);
vis[e.to]=1;
}
}
}
}
}
void spfa(int s){
queue<int>q;
memset(dis, inf, sizeof dis);
dis[s]=0;
vis[s]=1;
q.push(s);
while(!q.empty()){
int v=q.front();
q.pop();
vis[v]=0;
for(int i=head[v];i!=-1;i=rode[i].next)
{
node e=rode[i];
if(dis[e.to]>dis[v]+e.cost)
{
dis[e.to]=dis[v]+e.cost;
if(!vis[e.to])
{
q.push(e.to);
vis[e.to]=1;
}
}
}
}
}
int main()
{
int t;
cin >> t;
while(t--)
{
tol=0;
cin >> n >> m;
memset(head, -1, sizeof head);
memset(head1, -1, sizeof head1);
for (int i = 1; i <= m;i++)
{
ll a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
add1(b, a, c);
}
ll sum = 0;
spfa(1);
for (int i = 2; i <= n;i++)
{
sum += dis[i];
}
tol = 0;
spfa1(1);
for (int i = 2; i <= n;i++)
{
sum += dis[i];
}
cout << sum << endl;
}
//system("pause");
return 0;
}
J. 程序设计：迷宫
有一个 n×m 的迷宫，其中 . 表示空地， * 表示障碍物。除此之外，有 qq 个单向传送门：如果进入格子 (ai,bi)，那么会被立即传送到 (ci,di)。保证每个点至多是一个传送门的入口。
如果传送门最终传送到障碍物上，那么将会卡在障碍物上不能移动。
在传送门内部传送的花费是 00，在空地上每次可以往周围四个格子移动，花费是 11。
现在我们想知道从 (1,1) 走到 (x,y) 的最短距离。如果无法到达终点，输出 “No solution”（不含引号）。只要经过终点就算到达，即如果终点上有传送门也没有关系。
输入格式
第一行两个整数 n,m ，表示地图大小。
接下来 n 行，每行 m 个字符，表示地图。
接下来一行一个整数 q ，表示传送门个数。
接下来 q 行，每行四个整数 ai,bi,ci,di
最后一行两个整数 x,yx,y 表示目的地。
输出格式
一个整数表示最短距离。
数据范围
对于 20%20% 的数据： 0 < n, m \leq 50, 0 \leq q \leq 100<n,m≤50,0≤q≤10
对于 50%50% 的数据： 0 < n, m \leq 200, 0 \leq q \leq 300<n,m≤200,0≤q≤30
对于 80%80% 的数据： 0 < n, m \leq 500, 0 \leq q \leq 700<n,m≤500,0≤q≤70
对于 100%100% 的数据： 0 < n, m \leq 1000, 0 \leq q \leq 1000<n,m≤1000,0≤q≤100
样例输入
3 4
….
….
…*.
2
2 2 2 4
3 1 1 4
3 4
样例输出
3
其实就是bfs最短路径，写个map记录每个具有传送功能的点，然后跑一遍bfs，如果当前队首元素是到（1,1）距离为-1的点或者是障碍物，那直接跳过，如果是具有传送功能的点，那么把他放进队列，让当前点距离跟它传送到的点到原点的距离相同，其他情况就正常的把扩展到的点到原点距离+1.
代码：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<bitset>
#include<vector>
#include<queue>
#include<stack>
#include<map>
using namespace std;
const int maxn = 1e3 + 100;
const int inf=0x3f3f3f3f;
typedef long long ll;
typedef pair<int, int> pii;
ll gcd(ll x, ll y) { return y == 0 ? x : gcd(y, x % y); }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int dix[4] = {0, 0, 1, -1};
int diy[4] = {1, -1, 0, 0};
char a[maxn][maxn];
int n, m, q, flag, mi = inf, dis[maxn][maxn], f[maxn][maxn], ex, ey;
map<pii, pii> mmp;
void bfs(int x,int y)
{
queue<pii> q;
//memset(vis, 0, sizeof vis);
dis[1][1] = 0;
q.push(make_pair(1,1));
while(!q.empty())
{
pii t = q.front();
q.pop();
if(a[t.first][t.second]=='*'||dis[t.first][t.second]==-1)continue;
else if(mmp.find(t)!=mmp.end())
{
pii p = mmp[make_pair(t.first,t.second)];
dis[p.first][p.second] = dis[t.first][t.second];
q.push(p);
}
else
{
for (int i = 0; i < 4;i++)
{
int dx = t.first + dix[i];
int dy = t.second + diy[i];
if(dx<=0||dx>n||dy<=0||dy>m||a[dx][dy]=='*'||dis[dx][dy]!=-1)continue;
dis[dx][dy] = dis[t.first][t.second] + 1;
q.push(make_pair(dx, dy));
}
}
}
}
int main()
{
cin >> n >> m;
for (int i = 1; i <= n;i++)
for (int j = 1; j <= m;j++)
{
cin >> a[i][j];
}
cin >> q;
while(q--)
{
int x, y, x1, y1;
cin >> x >> y >> x1 >> y1;
mmp[make_pair(x, y)] = make_pair(x1, y1);
}
cin >> ex >> ey;
memset(dis, -1, sizeof dis);
bfs(1, 1);
if(dis[ex][ey]!=-1)
cout << dis[ex][ey] << endl;
else
{
cout << "No solution" << endl;
}
//system("pause");
return 0;
}
扫一扫
7543
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
