A. Long Live（数学）
题意：给定两个数，x和y，找出a和b，满足sqrt（lcm（x，y）/gcd（x，y））=a*sqrt（b）使得a×b最大
分析：lcm（x，y）/（gcd（x，y）×a×a）=b
最小公倍数
```
ll lcm(ll a, ll b) // 最小公倍数
{
return (ll)a / __gcd(a, b) * b;
}
```
x×y/(__gcd(x,y)*__gcd(x,y)×a×a)=b
b=k×（1/a*a）将图像画出，发现当a=1是，a×b最大
代码：
```
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int t; cin>>t;
while(t--){
ll x,y; cin>>x>>y;//
ll a=1,b;
b=x*y/(__gcd(x,y)*__gcd(x,y));//
cout<<a<<" "<<b<<endl;
}
return 0;
}
```
B. Nana Likes Polygons（枚举）
题意：有一些点，希望能形成途多边形的顶点子集作为端点，算出最小的面积，如果没有就输出-1
分析：枚举三个点，算出最小的面积
代码：
```
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e6 + 10;
struct node
{
double x;
double y;
} po[N];
int main()//
{
int t;
cin >> t;
while (t--)//
{
double ans = 0x3f3f3f3f;
int n;
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> po[i].x >> po[i].y;
}
for (int i = 0; i < n; i++)
{
for (int j = i + 1; j < n; j++)
{
for (int z = j + 1; z < n; z++)
{
double sum = po[j].x * po[z].y - po[z].x * po[j].y + po[i].x * po[j].y - po[j].x * po[i].y - po[i].x * po[z].y + po[z].x * po[i].y;
sum = abs(sum);
if (sum != 0)
{
ans = min(ans, sum / 2.0);
}
}
}
}
if (ans == 0x3f3f3f3f)//
{
cout << "-1" << "\n";
}
else//
{
cout << ans << "\n";
}//
}
}
```
E. Spicy or Grilled?（签到）
题意：套餐1 a元，套餐2 b元，每个人都要买，一共n人，x人要买套餐2，求一共花费多少元
分析：(n-x)*a+x*b
代码：
```
#include<bits/stdc++.h>
using namespace std;
void sol(){
int n,x,a,b;cin>>n>>x>>a>>b;
cout<<(n-x)*a+x*b<<endl;
}
int main(){
int t;cin>>t;
while(t--)sol();
return 0;
}
```
## J. Points on the Number Axis A（逆元，数学）
题意：有n个点，每次选择两个，并加上中点，求最后一个点在哪
分析：将所有数字加起来，并对n逆元
代码：
```
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=998244353;
ll qpow2(ll a,ll b,ll p){
ll base=a;
ll res=1;
while(b){
if(b&1)res=(res*base)%p;
base=(base*base)%p;
b>>=1;
}
return res;
}
ll inv(ll a,ll b)
{
return (a*qpow2(b,mod-2,mod))%mod;
}
int main(){
int n;cin>>n;ll a[n+10];ll sum=0;
for(int i=1;i<=n;i++){
cin>>a[i];sum=(sum+a[i])%mod;
}
cout<<inv(sum,n)<<endl;
}
```
H. Genshin Impact Startup Forbidden III（bfs）
题意：有n×m的池塘，（xi，yi）有ai条鱼，每次可以用十字行炸弹炸鱼，每次只能炸死一条，最少需要的炸弹数目
分析：用bfs找到从初始状态到全0的最短路!
代码：
```
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+1e5;
typedef pair<int,int> pi;
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
vector<vector<int>>state;
map<pi,vector<int>>r;//存储每个点及其周围点的信息
int main(){
int n,m,k,x[20],y[20],z[20],dist[N];scanf("%d%d%d",&n,&m,&k);
vector<int>v;//初始状态
for(int i=0;i<k;i++){
scanf("%d%d%d",&x[i],&y[i],&z[i]);
v.push_back(z[i]);
}
for(int i=0;i<k;i++){
r[pi(x[i],y[i])].push_back(i);
for(int j=0;j<4;j++){
int nx=x[i]+dx[j],ny=y[i]+dy[j];
if(nx<1||nx>n||ny<1||ny>m)continue;
r[pi(nx,ny)].push_back(i);//放了炸鱼的地方
}
}
//这里说的炸鱼的地方是指炸鱼的地方的四周有炸鱼的地方
for(auto [it,vec]:r){//往state容器存入炸鱼的地方
state.push_back(vec);
}
auto H=[&](vector <int>&vec){//vector里的转哈希
int q=0;
for(auto x:vec){
q=q*4+x;
}
return q;
};
memset(dist,-1,sizeof(dist));
queue<vector<int>>q;
q.push(v);
dist[H(v)]=0;
while(!q.empty()){
auto cur=q.front();
q.pop();
int hc=H(cur);
for(auto& vec:state){
auto nxt=cur;
for(auto& x:vec){
if(nxt[x]>0)--nxt[x];
}
int hn=H(nxt);
if(~dist[hn])continue;
dist[hn]=dist[hc]+1;
q.push(nxt);
}
}
printf("%d",dist[0]);
return 0;
}
```
G. Genshin Impact Startup Forbidden Il（bfs）
题意：给定围棋规则，若四周被其他颜色的包围将被包围区域换对方棋子，判断在给定下棋步数过程中双方被吃掉的棋子个数。
思路：通过两次bfs搜索来识别棋子颜色，找到周围同颜色的棋子并且判断是否完全被包围，是则对该区域的颜色翻转并记录个数。找颜色不同的棋子同样执行bfs并可能翻转颜色。
代码：
```
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
ll n,m;
int s[21][21];//存储每个格子的颜色 初始为-1
int ans[3];//存储每种颜色翻转后的数量
int dx[]={0,0,1,-1},dy[]={1,-1,0,0};
bool st[21][21];//跟踪在BFS过程中是否访问过某个格子
void bfs (int x,int y){//找到所有与给定起点相连的、颜色相同的格子
int c = s[x][y];
queue<PII> q;
q.push({x,y});
st[x][y]=true;//已访问
bool ok = false; //是否找到了颜色不同的
vector<PII> v;
while(!q.empty()){
auto [x,y]=q.front();
q.pop();
v.push_back({x,y});
for(int i=0;i<4;i++){
int a=x+dx[i],b=y+dy[i];
if(a<1 or a>n or b<1 or b>n) continue;//表示越界
if(s[a][b]==-1) ok = true;
if(s[a][b]!=c or st[a][b]) continue; // 表示不是同一个颜色 或者 被使用过了
q.push({a,b});
st[a][b]=true;
}
}
if(!ok){//ok=false 没有发现四周颜色不同
for(auto&[x,y]:v){//翻转所有访问过的格子的颜色，并将它们标记为-1
s[x][y]=-1;
ans[c]++;
}
}
}
void get(int op,vector<PII>&t){
memset(st,0,sizeof st);
for(auto&[x,y]:t){
if(x<1 or x>n or y<1 or y>n) continue;//边界内
if(st[x][y]) continue;//是否访问过
if(s[x][y]!=op) continue;//颜色是否相同
bfs(x,y);//界内的没访问过的同颜色的进行bfs
}
for(auto&[x,y]:t){//处理与操作颜色 op 不同的格子
if(x<1 or x>n or y<1 or y>n) continue;
if(st[x][y]) continue;
if(s[x][y]!=1^op) continue;//检查该坐标的颜色是否与操作颜色 op 的反值（通过 1^op 计算）相同
bfs(x,y);//界内的没访问过的不同颜色的进行bfs
}
}
void solve(){
n = 19;
memset(s,-1,sizeof s);
cin>>m;
for(int i=1;i<=m;i++){
int x,y; cin>>x>>y;
int op = i%2;//用于标记奇数和偶数迭代
s[x][y] = op;
ans[1]=ans[0]=0;
vector<PII> t;
for(int i=0;i<4;i++) t.push_back({x+dx[i],y+dy[i]});//周围四点
t.push_back({x,y});
get(op^1,t);//0^1=1 1^1=0
cout << ans[1] << ' ' << ans[0] << endl;
}
return ;
}
int main(){
solve();
return 0;
}
```
L. LCMs(最短路)
题意：给定起点和终点，求起点到终点的最短路径，任意两点的路径为lcm（x，y）最小公倍数
分析：=lcm(a,x1)+lcm(x1,x2)+lcm(x2,x3)+.....+lcm(xk+b)
为了让路径尽可能地小，假设此时插入的点位x1且只插入x1
a=6,b=7 x1=2 lcm(6,2)+lcm(2,7)=20 x1=3 lcm(6,3)+lcm(3,7)=27可以发现当x1取a或者b的最小因子（除了1）时，路径最短，或者取两者的共同因子时，例如10和15 取5，此时路径最短或者取2时，路径也有可能最短，那么可以存这几个点的值，求出互相之间的lcm，相同的数取0，保存在路径中，flord求最短路。求出a，b，a的最小公倍数不含1，b的最小公倍数不含1，2的最短路
代码:
```
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 110;
ll c[110], g[110][110];
ll cnt = 0;
ll lcm(ll a, ll b) // 最小公倍数
{
return (ll)a / __gcd(a, b) * b;
}
void floyd()
{
for (int i = 1; i <= cnt; i++) // 建路，相同的数为0，不同的数直接求解lcm
{
for (int j = 1; j <= cnt; j++)
{
if (i == j)
{
g[i][j] = 0;
}
else
{
g[i][j] = lcm(c[i], c[j]);
}
}
}
for (int p = 1; p <= cnt; p++)
{
for (int i = 1; i <= cnt; i++)
{
for (int j = 1; j <= cnt; j++)
{
g[i][j] = min(g[i][j], g[i][p] + g[p][j]);
}
}
}
}
signed main()
{
int t;
cin >> t;
while (t--)
{
memset(c, 0, sizeof c);
cnt = 0;
ll a, b;
cin >> a >> b;
c[++cnt] = a;
c[++cnt] = b;
c[++cnt] = 2;
if (__gcd(a, b) != 1)
{
c[++cnt] = __gcd(a, b);
}
for (int i = 2; i * i <= a; i++)
{ // 存a最小因子
if (a % i == 0)
{
c[++cnt] = i;
break;
}
}
for (int i = 2; i * i <= b; i++)
{ // 存b最小因子
if (b % i == 0)
{
c[++cnt] = i;
break;
}
}
sort(c + 1, c + 1 + cnt);
cnt = unique(c + 1, c + 1 + cnt) - c - 1; // 去重
ll s = 0;
for (int i = 1; i <= cnt; i++)
{
if (c[i] == a){
s = i; // 起点
break;
}
}
floyd();
// 起点a到结尾k的最短路径
cout << g[s][cnt] << '\n';
}
return 0;
}#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 110;
ll c[110], g[110][110];
ll cnt = 0;
ll lcm(ll a, ll b) // 最小公倍数
{
return (ll)a / __gcd(a, b) * b;
}
void floyd()
{
for (int i = 1; i <= cnt; i++) // 建路，相同的数为0，不同的数直接求解lcm
{
for (int j = 1; j <= cnt; j++)
{
if (i == j)
{
g[i][j] = 0;
}
else
{
g[i][j] = lcm(c[i], c[j]);
}
}
}
for (int p = 1; p <= cnt; p++)
{
for (int i = 1; i <= cnt; i++)
{
for (int j = 1; j <= cnt; j++)
{
g[i][j] = min(g[i][j], g[i][p] + g[p][j]);
}
}
}
}
signed main()
{
int t;
cin >> t;
while (t--)
{
memset(c, 0, sizeof c);
cnt = 0;
ll a, b;
cin >> a >> b;
c[++cnt] = a;
c[++cnt] = b;
c[++cnt] = 2;
if (__gcd(a, b) != 1)
{
c[++cnt] = __gcd(a, b);
}
for (int i = 2; i * i <= a; i++)
{ // 存a最小因子
if (a % i == 0)
{
c[++cnt] = i;
break;
}
}
for (int i = 2; i * i <= b; i++)
{ // 存b最小因子
if (b % i == 0)
{
c[++cnt] = i;
break;
}
}
sort(c + 1, c + 1 + cnt);
cnt = unique(c + 1, c + 1 + cnt) - c - 1; // 去重
ll s = 0;
for (int i = 1; i <= cnt; i++)
{
if (c[i] == a){
s = i; // 起点
break;
}
}
floyd();
// 起点a到结尾k的最短路径
cout << g[s][cnt] << '\n';
}
return 0;
}
```
1974
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
