今日总结2024/5/26

今日学习了筛素数,两种最短路

大于1的整数 一定可以表示为素数的乘积。

对于合数 a，一定存在素数p<=sqrt(a) 使得p|a。

判断是否为素数

bool isprime(int x){
	if(x<2) return false;
	for(int i=2;i<=x/i;i++)
	if(x%i==0)
	return false;
	return true;
}

线性筛

const int N=1e6;
bool not_prime[N];
vector<int> pri;

void cal(int n){
	not_prime[1]=true;
	for(int i=2;i<=n;i++){
		if(!not_prime[i]){
			pri.push_back(i);
		}
		for(auto x:pri){
			if(i*x>n) break;
			not_prime[i*x]=true;
			if(i%x==0) break; 
		}
	}
}

P1217 [USACO1.5] 回文质数 Prime Palindromes

查询区间要5≤a<b≤100,000,000,所以筛素数要用线性的欧拉筛,且不能开vector否则内存会超限

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int N=1e8+2;
bool not_prime[N];
int pri[N],cnt;

bool check(int x){//判断是否回文
	int tmp=x,rev=0;
	while(tmp){
		rev=rev*10+tmp%10;
		tmp/=10;
	}
	if(rev==x) return true;
	else return false;
}

int main(){
	not_prime[1]=true;
	for(int i=2;i<=1e8;i++){//线性筛
		if(!not_prime[i]){
			pri[++cnt]=i;
		}
		for(int j=1;j<=cnt;j++){
			int x=pri[j];
			if((long long)i*x>1e8) break;//相乘可能超出int
			not_prime[i*x]=true;
			if(i%x==0) break;
		}
	}
	int a,b;cin>>a>>b;
	for(int j=1;j<=cnt;j++){
		int x=pri[j];
		if(x<a) continue;
		if(x>b) break;
		if(check(x))
		cout<<x<<'\n';
	}
	return 0;
}

L2-001 紧急救援

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式:

输入第一行给出4个正整数N、M、S、D，其中N（2≤N≤500）是城市的个数，顺便假设城市的编号为0 ~ (N−1)；M是快速道路的条数；S是出发地的城市编号；D是目的地的城市编号。

第二行给出N个正整数，其中第i个数是第i个城市的救援队的数目，数字间以空格分隔。随后的M行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式:

第一行输出最短路径的条数和能够召集的最多的救援队数量。第二行输出从S到D的路径中经过的城市编号。数字间以空格分隔，输出结尾不能有多余空格。

本题要存路径，要存路线最短时，同时取得最大的消防员数量，因此要在更新最短距离时考虑出最短距离相等时，要选择消防员最多的那个数目,同时更新距离时要记录是从哪里来的，用一个path数组记录父结点，之后递归输出即可

#include <bits/stdc++.h>
using namespace std;
const int N=1e6,M=510;
typedef pair<int,int> PII;
int h[M],ne[N],e[N],w[N],idx,n,m,s,d;
int roadnum[M],maxnum[M],have[M],path[M],dist[M];
bool visited[M];

void add(int a,int b,int c){
    ne[idx]=h[a];
    e[idx]=b;
    w[idx]=c;
    h[a]=idx++;
}

void dijkstra(){
    memset(dist,0x3f,sizeof dist);
    memset(path,-1,sizeof path);
    dist[s]=0;
    roadnum[s]=1;//开始一条
    maxnum[s]=have[s];//开始有当前消防队员
    priority_queue<PII,vector<PII>,greater<PII>> q;
    q.push({0,s});
    while(q.size()){
        PII t=q.top();
        q.pop();
        int distance=t.first,enter=t.second;
        if(visited[enter]) continue;
        visited[enter]=true;
        for(int i=h[enter];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>distance+w[i]){
                path[j]=enter;//存从哪走过去的
                roadnum[j]=roadnum[enter];
                maxnum[j]=maxnum[enter]+have[j];
                dist[j]=distance+w[i];
                q.push({dist[j],j});
            }else if(dist[j]==distance+w[i]){
                roadnum[j]+=roadnum[enter];
                if(maxnum[j]<maxnum[enter]+have[j]){
                    path[j]=enter;
                    maxnum[j]=maxnum[enter]+have[j];//j才是顶点编号
                }
            }
        }
    }
}

void printpath(int u){
    if(path[u]!=-1) printpath(path[u]);
    if(u!=d)
    cout<<u<<' ';
    else cout<<u<<'\n';
}

int main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    memset(h,-1,sizeof h);
    cin>>n>>m>>s>>d;
    for(int i=0;i<n;i++) cin>>have[i];
    for(int i=1;i<=m;i++){
        int a,b,c;cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    dijkstra();
    cout<<roadnum[d]<<' '<<maxnum[d]<<'\n';
    printpath(d);
    return 0;
}

AcWing 854. Floyd求最短路

由动态规划可得

状态表示f[k,i,j]表示经过k点i到j的距离的最小值

状态计算为f[k,i,j]=min(f[k-1,i,k]+f[k-1,k,j],f[k-1,i,j])表示不经过k点，从1-(k-1)个点中i到k的距离加上不经过k点1-(k-1)个点中从k到j的距离和不经过k点i直接到j中取一个最小的即可

#include <bits/stdc++.h>
using namespace std;
const int N=210,INF=0x3f3f3f3f;
int g[N][N],n,m,k;;

void floyd(){//基于动态规划
	for(int k=1;k<=n;k++)
	for(int i=1;i<=n;i++)
	for(int j=1;j<=n;j++)
	g[i][j]=min(g[i][k]+g[k][j],g[i][j]);//选择经过k点和不选择经过k点
}

int main(){
	memset(g,0x3f,sizeof g);//距离初始化为负无穷
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++) g[i][i]=0;//初始化自己到自己距离为0防止自环
	
	for(int i=1;i<=m;i++){//读入m条边
		int a,b,c;cin>>a>>b>>c;
		g[a][b]=min(g[a][b],c);//防止重边和自环
	}
	
	floyd();
	while(k--){
		int a,b;cin>>a>>b;
		if(g[a][b]>INF/2) cout<<"impossible";//可能存在负权边但倒数第二个点没有联通
		else cout<<g[a][b];
	}
	return 0;
}