【数字_ID】CUC Spring最小生成树图论解

最新推荐文章于 2023-07-05 21:00:57 发布
最新推荐文章于 2023-07-05 21:00:57 发布
阅读量297 收藏 1
点赞数 1
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq975678774/article/details/89346851
版权

文章目录

Rikka with Minimum Spanning Trees Gym - 102012A

这道题是去年徐州区域赛的"签到题"，也是我印象很深刻的打铁场。最小生成树计数，但是！！！ 数据随机，其实就有很大概率不连通，或者只有一个最小生成树，所以就莽一发，拼人品，赌它只有一个最小生成树，那么把权值和输出就行了。（是不是很坑？是不是很坑！！）(之所以放在第一道，因为现场赛时也是A题，而且好多人都莽过去了…）

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <functional>
#include <algorithm>
#include <queue>
#include <stdio.h>
#define INF 0x7f7f7f7f
#define ull unsigned long long
using namespace std;
const int maxn = 100020;
const int MOD = 1e9+7;

ull k1,k2;
int n,m;
int fa[maxn];

void init(int n)
{
    for(int i = 0;i<=n;i++)fa[i] = i;
}
int find(int x)
{
    return (fa[x] == x)?x : fa[x] = find(fa[x]);
}
struct Edge{
    int u,v;
    ull w;
}edge[maxn];

unsigned long long xors()
{
    ull k3=k1,k4=k2;
    k1=k4;
    k3^=k3<<23;
    k2=k3^k4^(k3>>17)^(k4>>26);
    return k2+k4;
}

void gen()
{
    //scanf("%d%d%llu%llu" , &n,&m,&k1,&k2);
    scanf("%d%d%llu%llu",&n,&m,&k1,&k2);
    //cin >> n >> m >>k1 >>k2;
    for(int i = 1;i<=m;i++)
    {
        edge[i].u = xors() % n + 1;
        edge[i].v = xors() % n + 1;
        edge[i].w = xors();
    }
}

bool cmp(Edge a,Edge b)
{
    return a.w < b.w;
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        gen();
        init(n);
        int ct = 0;
        ull sum = 0;
        sort(edge+1,edge+1+m,cmp);
        for(int i = 1;i<=m;i++)
        {
            int fx = find(edge[i].u);
            int fy = find(edge[i].v);
            if(fx != fy){
                ct ++;
                fa[fx] = fy;
                sum = (sum + edge[i].w)%MOD;
            }
        }
        if(ct != n-1)printf("0\n");
        else printf("%llu\n" , sum);
    }
}

Networking POJ - 1287

一个简单的最小生成树的题

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;

const int maxn = 10020;

int fa[maxn];
int ct = 0;
int ans;
struct Edge{
    int u,v,w;
}edge[maxn];

void init(int n)
{
    ct = 0;
    ans = 0;
    for(int i = 0;i<=n;i++)
    {
        fa[i] = i;
    }
}

void addedge(int u,int v,int w)
{
    edge[ct].u = u;
    edge[ct].v = v;
    edge[ct].w = w;
    ct ++;
}
bool cmp(Edge a,Edge b)
{
    return a.w<b.w;
}

int find(int x)
{
    return (fa[x] == x)?fa[x]:fa[x] = find(fa[x]);
}
int n,m;
int main()
{
    while(cin >> n && n){
        init(n);
        cin >> m;
        for(int i = 0;i<m;i++){
            int u,v,w;
            cin >> u >> v >> w;
            addedge(u,v,w);
        }
        sort(edge,edge+ct,cmp);
        for(int i = 0;i<ct;i++)
        {
            int u = edge[i].u , v = edge[i].v;
            int fx = find(u) , fy = find(v);
            if(fx != fy){
                fa[fx] = fy;
                ans += edge[i].w;
            }
        }
        cout << ans << endl;
    }
}

最短路径·一 HihoCoder - 1081

最短路裸题，我用dijk写的

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <functional>
#include <algorithm>
#include <queue>
#define INF 0x7f7f7f7f
using namespace std;

const int maxn = 10020;

int ct = 0;
int ans;
int n,m,s,t;
int head[maxn];
int dis[maxn];
struct {
    int v , w , next;
}edge[2*maxn];

struct node{
    int x;
    int dis;
    bool operator < (const node b)const{
        return dis > b.dis;
    }
};


void init(int n)
{
    for(int i = 0;i<=n;i++)head[i] = -1 ,dis[i] = INF ;
    ct = 0;
}

void addedge(int u,int v,int w)
{
    edge[ct].v = v;
    edge[ct].w = w;
    edge[ct].next = head[u];
    head[u] = ct++;
}

void dijk(int now)
{
    node st;
    st.x = now;
    st.dis = 0;
    dis[now] = 0;
    priority_queue<node>Q;
    Q.push(st);
    while(!Q.empty())
    {
        node t = Q.top();
        Q.pop();
        if(dis[t.x] != t.dis)continue;
        for(int i = head[t.x];~i;i = edge[i].next)
        {
            int to = edge[i].v;
            if(dis[t.x] + edge[i].w < dis[to]){
                dis[to] = dis[t.x] + edge[i].w;
                //cout << "to = " << to << " , dis[to] = " <<dis[to] << endl;
                Q.push((node){to , dis[to]});
            }
        }
    }

}
int main()
{
    int T;
    //cin >> T;
    //for(int tt = 1;tt<=T;tt++)
   // {
        cin >> n >> m >> s >>t;
        init(n);
        for(int i = 0;i<m;i++)
        {
            int u,v,w;cin >> u >> v >>w;
            addedge(u,v,w);
            addedge(v,u,w);
            //cout << "fuck" <<endl;
        }
        dijk(s);
        cout << dis[t] << endl;
   // }
}

最短路径·二：Floyd算法 HihoCoder - 1089

裸题，希望可以自己实现，非常好记

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<queue>
#define clr(x,b) memset(x,(b),sizeof(x))
#define fuck cout<<"fuck:"<<__LINE__<<____endl
#define MOD (ll)(1e9+7)

using namespace std;

const int maxn = 120;
const int maxm = 1020;
int _mp[maxn][maxn];
int n,m;
int main()
{
	cin>>n>>m;
	clr(_mp,0x3f3f3f3f);
	for(int i = 0;i<=n;i++)_mp[i][i] = 0;
	for(int i = 0;i<m;i++){
		int u,v,l;cin>>u>>v>>l;
		if(_mp[u][v]>l){
			_mp[u][v] = l;
			_mp[v][u] = l;
		}
	}
	for(int k = 1;k<=n;k++){
		for(int i = 1;i<=n;i++){
			for(int j = 1;j<=n;j++){
				_mp[i][j] = min(_mp[i][j],_mp[i][k]+_mp[k][j]);
			}
		}
	}
	for(int i = 1;i<=n;i++){
		for(int j = 1;j<=n;j++){
			cout<<_mp[i][j]<<" ";
		}
		cout<<endl;
	}
}

最短路径·三：SPFA算法 HihoCoder - 1093

也可以用别的方法，这里我是为了练习spfa，所以用的spfa

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<queue>
#include<vector>
#define clr(x,b) memset(x,(b),sizeof(x))
#define fuck cout<<"fuck:"<<__LINE__<<endl;
using namespace std;

const int maxn = 1e5+21;
const int maxm  = 1e6+20;
int S,T,n,m;
int ct = 0;
int dis[maxn];
bool inq[maxn];
int num[maxn];
int head[maxn];
struct edge{
	int to;
	int len;
	int next;
}E[maxm]; 
struct node{
	int x;
	int dis;
	bool operator < (const node b)const{
		return dis<b.dis;
	}
};
void addedge(int u,int v,int w){
	E[ct].to = v;
	E[ct].len = w;
	E[ct].next = head[u];
	head[u] = ct++;
}

void spfa(){
	queue<int>Q;
	Q.push(S);
	inq[S] = true;
	dis[S] = 0;
	num[S]++;
	while(!Q.empty()){
		int t = Q.front();
		Q.pop();
		inq[t] = false;
		for(int i = head[t];i!=-1;i = E[i].next){
			int x = E[i].to;
			int l = E[i].len;
			if(dis[x]>dis[t]+l){
				dis[x] = dis[t]+l;
				if(!inq[x]){
					inq[x] = true;
					Q.push(x);
					num[x] ++ ;
					if(num[x]>n)return;
				}
			}
		}
	}
}


int main(){
	ct = 0;
	clr(head,-1);
	clr(inq,0);
	clr(dis,0x3f3f3f3f);
	clr(num,0);
	cin>>n>>m>>S>>T;
	for(int i = 0;i<m;i++){
		int u,v,l;cin>>u>>v>>l;
		addedge(u,v,l);
		addedge(v,u,l);
	}
	spfa();
	//fuck
	cout<<dis[T]<<endl;

}

最小生成树一·Prim算法 HihoCoder - 1097

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<queue>
#include<vector>
#define clr(x,b) memset(x,(b),sizeof(x))
#define fuck cout<<"fuck:"<<__LINE__<<endl;
#define INF 0x3f3f3f3f
using namespace std;

const int maxn = 1020;
bool visit[maxn];
int dis[maxn];
int G[maxn][maxn];
int ans = 0;
int n;
void prim(){
	dis[1] = 0;
	for(int i = 0;i<n;i++){
		int mn = INF;
		int pos = 0;
		for(int j = 1;j<=n;j++){
			if(visit[j])continue;
			if(dis[j]<mn){
				mn = dis[j];
				pos = j;
			}
		}
		if(pos == 0)break;
		visit[pos] = true;
		ans += dis[pos];
		//dis[pos] = 0;
		for(int j = 1;j<=n;j++){ 
			dis[j] = min(dis[j],G[pos][j]);
		} 
	}
}
int main(){
	clr(dis,INF);
	cin>>n;
	for(int i = 1;i<=n;i++){
		for(int j = 1;j<=n;j++){
			int a;cin>>a;
			G[i][j] = a;
		}
	}
	prim();
	//fuck
	cout<<ans<<endl;
}

最小生成树二·Kruscal算法 HihoCoder - 1098

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<queue>
#include<vector>
#define clr(x,b) memset(x,(b),sizeof(x))
#define fuck cout<<"fuck:"<<__LINE__<<endl;
using namespace std;

const int maxm = 1e6+20;
const int maxn = 1e5+20;
struct edge{
	int u;
	int v;
	int len;
}E[maxm];

bool cmp(edge a,edge b){
	return a.len<b.len;
}
bool visit[maxm];
int fa[maxn];
int n,m;
void init(){
	for(int i = 0;i<=n;i++)fa[i] = i;
}
int find(int x){
	return (fa[x] == x)?x:fa[x] = find(fa[x]);
}

void join(int a,int b){
	int x = find(a);
	int y = find(b);
	if(x!=y)fa[x] = y;
}

int main()
{
	cin>>n>>m;
	clr(visit,0);
	init();
	for(int i = 0;i<m;i++){
		cin>>E[i].u>>E[i].v>>E[i].len;
	}
	sort(E,E+m,cmp);
	int ans = 0;
	for(int i = 0;i<m;i++){
		int u = E[i].u;
		int v = E[i].v;
		int l = E[i].len;
		int x = find(u);
		int y = find(v);
		if(x!=y){
			fa[x] = y;
			ans += l;
		}
		else continue;
	}
	cout<<ans<<endl;
}

Heavy Transportation POJ - 1797

从1到n的所有路径中，输出最小值最大的路径的最小值，dijk变一下，用dis维护到当前点的最小值，每次更新时dis[x] = max(dis[t] , min(edte[i].w,dis[t.x]));，记得优先队列中弹出的点事是离源点路径中最小值最大的点

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <functional>
#include <algorithm>
#include <queue>
#include <stdio.h>
#define INF 0x7f7f7f7f
using namespace std;

const int maxn = 20020;
const int maxm = 1000020;
int ct = 0;
int ans;
int n,m,s,t;
int head[maxn];
int dis[maxn];
struct {
    int v , w , next;
}edge[2*maxm];

struct node{
    int x;
    int dis;
    bool operator < (const node b)const{
        return dis < b.dis;
    }
};


void init(int n)
{
    for(int i = 0;i<=n;i++)head[i] = -1 ,dis[i] = 0 ;
    ct = 0;
}

void addedge(int u,int v,int w)
{
    edge[ct].v = v;
    edge[ct].w = w;
    edge[ct].next = head[u];
    head[u] = ct++;
}

void dijk(int now)
{
    node st;
    st.x = now;
    st.dis = INF;
    dis[now] = INF;
    priority_queue<node>Q;
    Q.push(st);
    while(!Q.empty())
    {
        node t = Q.top();
        Q.pop();
       // cout << t.x << endl;
        if(dis[t.x] > t.dis)continue;
        for(int i = head[t.x];~i;i = edge[i].next)
        {
            int to = edge[i].v;
            if(min(dis[t.x] , edge[i].w) > dis[to]){
                dis[to] = min(dis[t.x] , edge[i].w);
                //cout << "to = " << to << " , dis[to] = " <<dis[to] << endl;
                Q.push((node){to , dis[to]});
            }
        }
    }

}
int main()
{
    int T;
    scanf("%d" , &T);
    for(int tt = 1;tt<=T;tt++)
    {
        //cin >> n >> m ;
        scanf("%d%d" , &n , &m);
        init(n);
        for(int i = 0;i<m;i++)
        {
            int u,v,w;//cin >> u >> v >>w;
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
            addedge(v,u,w);
            //cout << "fuck" <<endl;
        }
        dijk(1);
        printf("Scenario #%d:\n%d\n\n",tt,dis[n]);
        //cout << dis[n] << endl;
    }
}

还是畅通工程 HDU - 1233

一个简单的最小生成树题

#include<iostream>
#include <algorithm>
using namespace std;
int n,ans;
int f[120];
typedef struct _fff
{
    int from,to,dis;
}FFF;
FFF edge[5020];
bool cmp(FFF a,FFF b)
{
    return a.dis < b.dis;
}
int find(int x)
{
    if(x!=f[x])f[x] = find(f[x]);
    return f[x];
}
void Union(int a,int b,int i)
{
    int x = find(a);
    int y = find(b);
    if(x == y)return;
    ans += edge[i].dis;
    f[y] = x;
}
int main()
{
    cin>>n;
    while(n)
    {
        ans = 0;
        for(int i=1;i<=n;i++)f[i] = i;
        int k =n*(n-1)/2;
        for(int i=0;i<k;i++)
        {
            cin>>edge[i].from>>edge[i].to>>edge[i].dis;
        }
        sort(edge,edge+k,cmp);
        for(int i = 0;i<k;i++)
        {
            Union(edge[i].from,edge[i].to,i);
        }
        cout<<ans<<endl;
        cin>>n;
    }
}

畅通工程再续 HDU - 1875

在最小生成树的基础上加了一下距离限制，多个if条件即可

# include <iostream>
# include <stdio.h>
# include <string.h>
# include <algorithm>
# include <math.h>
# include <queue>
# include <string>
# include <vector>
# include <set>
# include <map>
# define INF 0x3f3f3f3f
# define clr0(x) memset(x,0,sizeof(x))
# define clr1(x) memset(x,INF,sizeof(x))
# define clrf(x) memset(x,-1,sizeof(x))
# define rep(i,a) for(int i = 0;i<(a);i++)
# define repf(i,a,b) for(int i = (a);i<=(b);i++)
# define repu(i,a,b) for(int i = (a);i<(b);i++)
# define repd(i,a,b) for(int i = (a);i>=(b);i--)
# define lowbit x&(-x)
# define ww(a) while(a)
# define sc(x) scanf("%d",&(x))
# define sd(x) scanf("%I64d",&(x))
# define lson(x) (x)<<1
# define rson(x) (x)<<1|1
# define ll long long
# define fuckio ios::sync_with_stdio(false);
# define fuck cout<<"fuck:"<<__LINE__<<endl;
# define gcd(a,b) __gcd((a),(b))
# define maxn 120
using namespace std;


int fa[maxn];
int xx[maxn];
int yy[maxn];
int n,m,cnt,num;
void init()
{
    repf(i,0,n)fa[i] = i;
    cnt = 0;
    num = 0;
}

int find(int x)
{
    return (fa[x] == x)?x:fa[x] = find(fa[x]);
}

struct edge
{
    int u;
    int v;
    double len;
}E[maxn*maxn];

bool cmp(edge a,edge b)
{
    return a.len<b.len;
}


double kruskal()
{
    double ret = 0;
    rep(i,cnt){
        int fu = find(E[i].u);
        int fv = find(E[i].v);
        if(fu!=fv){
            fa[fu] = fv;            
            ret += E[i].len;
            num ++;
        }
    }
    return ret;
}
int main()
{
    int T;sc(T);
    ww(T--){
        sc(n);
        init();
        repf(i,1,n){
            scanf("%d%d",&xx[i],&yy[i]);
        }
        repf(i,1,n){
            repf(j,1,n){
                double tmp =sqrt((xx[i]-xx[j])*(xx[i]-xx[j])+(yy[i]-yy[j])*(yy[i]-yy[j]));
                if(tmp>=10&&tmp<=1000){
                    E[cnt].u = i;
                    E[cnt].v = j;
                    E[cnt++].len = tmp;       
                }
            }
        }
        sort(E,E+cnt,cmp);
        double ans = kruskal()*100;
        if(num!=n-1)printf("oh!\n");
        else printf("%.1lf\n",ans);
    }
}

地铁 CSU - 1808

每个点是地铁站，每个边表示属于几号线，现在有个代价是，如果路线中相邻的两个边属于的号线不一样，就需要有额外的 ∣ c i − c j ∣ |c_{i} - c_{j}| ∣ci​−cj​∣的换乘代价，问你从1号点到n号店的最小代价。我们这里需要加一个stt[maxn]数组又来记录，从原点到当前点，最后一次的乘车时几号线，然后维护最小值dis[to] = min(dis[to],edge[i].w + dis[t.x] + abs(stt[t.x] - edge[i].sta));。因为源点出发的时候，没有换乘，所以单独考虑。

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <functional>
#include <algorithm>
#include <queue>
#include <stdio.h>
#define INF 0x7f7f7f7f
using namespace std;

const int maxn = 200020;
const int maxm = 200020;
int ct = 0;
int ans;
int n,m,s,t;
int head[maxn];
int dis[maxn];
int stt[maxn];
struct {
    int v , w ,next ,  sta;
}edge[2*maxm];

struct node{
    int x;
    int dis;
    bool operator < (const node b)const{
        return dis > b.dis;
    }
};


void init(int n)
{
    for(int i = 0;i<=n;i++)head[i] = -1 ,dis[i] = INF ,stt[i] = 0;;
    ct = 0;
}

void addedge(int u,int v,int w,int sta)
{
    edge[ct].v = v;
    edge[ct].w = w;
    edge[ct].next = head[u];
    edge[ct].sta = sta;
    head[u] = ct++;
}

void dijk(int now)
{
    node st;
    st.x = now;
    st.dis = 0;
    stt[now] = INF;
    dis[now] = 0;
    priority_queue<node>Q;
    Q.push(st);
    while(!Q.empty())
    {
        node t = Q.top();
        Q.pop();
       // cout << t.x << endl;
        if(dis[t.x] < t.dis)continue;
        for(int i = head[t.x];~i;i = edge[i].next)
        {
            int to = edge[i].v;

            if(stt[t.x] == INF && edge[i].w + dis[t.x] < dis[to]){
                dis[to] = edge[i].w + dis[t.x] ;
                stt[to] = edge[i].sta;
                //cout << "to = " << to << " , dis[to] = " <<dis[to] << endl;
                Q.push((node){to , dis[to]});
            }else if(edge[i].w + dis[t.x] + abs(stt[t.x] - edge[i].sta) < dis[to]){
                dis[to] = edge[i].w + dis[t.x] + abs(stt[t.x] - edge[i].sta);
                stt[to] = edge[i].sta;
                Q.push((node){to , dis[to]});
            }
        }
    }

}
int main()
{
    while(~scanf("%d%d",&n,&m)){
        init(n);
        for(int i = 0;i<m;i++){
            int u,v,w,c;
            scanf("%d%d%d%d",&u,&v,&c,&w);
            addedge(u,v,w,c);
            addedge(v,u,w,c);
        }
        dijk(1);
        printf("%d\n",dis[n]);
    }
}

Wormholes POJ - 3259

给一个图，和一些权值为正的边，一些权值为负的边，权值为负的边是单向的，正的是双向的，问你有没有负环，我直接用spfa判断，如果有的点被访问次数大于n次，则说明产生了负环

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<queue>
#include<vector>
#include<map>
#define clr(x,b) memset(x,(b),sizeof(x))
#define fuck cout<<"fuck:"<<__LINE__<<endl;
using namespace std;

const int maxn = 100200;
const int maxm  = 100200;
int n,m,w;
int ct = 0;
int dis[maxn];
bool inq[maxn];
int head[maxn];
int num[maxn];
struct edge{
	int to;
	int len;
	int next;
}E[maxm]; 
struct node{
	int x;
	int dis;
	bool operator < (const node b)const{
		return dis<b.dis;
	}
};
void addedge(int u,int v,int w){
	E[ct].to = v;
	E[ct].len = w;
	E[ct].next = head[u];
	head[u] = ct++;
}

bool spfa(){
	queue<int>Q;
	int st = 1;
	dis[st] = 0;
	Q.push(st);
	inq[st] = true;
	num[st]++;
	while(!Q.empty()){
		
		int t = Q.front();
		Q.pop();
		inq[t] = false;
		for(int i = head[t];i!=-1;i = E[i].next){
			int d = E[i].to;
		//	if(inq[d])continue;
			if(dis[d]>dis[t]+E[i].len){
				//fuck
				dis[d] = dis[t]+E[i].len;
				if(!inq[d]){
					inq[d] = true;
					Q.push(d);
					num[d]++;
					if(num[d]>n)return true;
				}
				
			}
		}
	}
	return false;
}
int main(){
	int T;
	cin>>T;
	while(T--){
		clr(head,-1);
		ct = 0;
		clr(dis,0x3f3f3f3f);
		clr(num,0);
		clr(inq,0);
		cin>>n>>m>>w;
		for(int i = 0;i<m;i++){
			int u,v,l;cin>>u>>v>>l;
			addedge(u,v,l);
			addedge(v,u,l);
		}
		for(int i = 0;i<w;i++){
			int u,v,l;cin>>u>>v>>l;
			addedge(u,v,-l);
		}
		if(spfa())cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}


	//fuck
	
	
}

飞行路线 HYSBZ - 2763

分层最短路 ， 假设如果可以选择k个路，我们就想象有(k+1)个平行宇宙，每个平行宇宙的图是一样的，平行宇宙相邻两层之间的边权值为0，每次决定是否选择这条边，就意味着从这一层到达上一层，最后输出（k+1）个平行宇宙中的最小值即可,具体看建图那一块的代码

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <functional>
#include <algorithm>
#include <queue>
#include <stdio.h>
#define INF 0x7f7f7f7f
using namespace std;

const int maxn = 110020;
const int maxm = 1100020;
int ct = 0;
int ans;
int n,m,s,t,k;
int head[maxn];
int dis[maxn];
int stt[maxn];

struct Edge{
    int v , w ,next;
}edge[2*maxm];

struct node{
    int x;
    int dis;
    bool operator < (const node b)const{
        return dis > b.dis;
    }
};


void init(int n)
{
    for(int i = 0;i<=n;i++)head[i] = -1 ,dis[i] = INF ;
    ct = 0;
}

void addedge(int u,int v,int w)
{
    edge[ct].v = v;
    edge[ct].w = w;
    edge[ct].next = head[u];
    head[u] = ct++;
}

void dijk(int now)
{
    node st;
    st.x = now;
    st.dis = 0;
    dis[now] = 0;
    priority_queue<node>Q;
    Q.push(st);
    while(!Q.empty())
    {
        node t = Q.top();
        Q.pop();
       // cout << t.x << endl;
        if(dis[t.x] != t.dis)continue;
        for(int i = head[t.x];~i;i = edge[i].next)
        {
            int to = edge[i].v;
            if(dis[t.x] + edge[i].w < dis[to]){
                dis[to] = dis[t.x] + edge[i].w;
                Q.push((node){to,dis[to]});
            }
        }
    }

}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k)){
        init((k+1)*(n));
        scanf("%d%d",&s,&t);
        for(int i = 0;i<m;i++)
        {
            int u,v,w;
            scanf("%d%d%d" , &u,&v,&w);
            for(int j = 0;j<=k;j++)
            {
                addedge(u + j*n , v+j*n , w);
                addedge(v + j*n , u+j*n , w);
                if(j){

                    addedge(u+(j-1)*n , v+j*n , 0);
                    addedge(v+(j-1)*n , u+j*n , 0);
                }
            }
        }

        dijk(s);
        int mn = INF;

        for(int i = 0;i<=k;i++){
            //cout << dis[t + i*n] << endl;
            mn = min(mn , dis[t + i*n]);
        }
        printf("%d\n" , mn);

    }
}
数字_ID
关注
专栏目录
数字通信之编码（四）
starmier的博客
02-25 1447
数字通信系统之编码（四）1、编码的基本概念1.1、编码的概念及分类1.2、编码常用的二进制码组2、A律13折线编码的码字安排2.1、A律13折线非均匀量化间隔的划分2.2、A律13折线编码的码字安排2.2.1、A律13折线编码的量化间隔2.2.2、A律13折线编码的量化级数N2.2.3、A律13折线编码的码字安排3、编码3.1、A律13折线编码方法3.2、A律13折线编码的编解码电平3.3、A律13折线编码器3.3.1、码字判决与码形成电路3.3.2、判定值的提供电路3.4、A律13折线解码器 1、编码的基
CUC_Paraconc V0.3
08-21
《CUC_Paraconc V0.3：语料库检索工具的深度解析》 在语言学和文体学的研究中，有效的数据检索与分析是至关重要的。CUC_Paraconc V0.3是一款专为此目的设计的工具，它以其强大的功能和易用性，成为了学者们进行语料...
【数字_ID】CUC Spring 题解
IuMgXnWu
04-11 255
CUC Spring 题解 制作时间：2019年4月5日02:58:20 How Many Answers Are Wrong HDU - 3038 带权并查集，对于任何一个u,v,w，(u&lt;v)u,v,w，(u&lt;v)u,v,w，(u<v) , 表示,[u,v+1)[u,v+1)[u,v+1)的值之和，val[u]val[u]val[u]便是uuu到其fat...
【数字_ID】CUC Spring 14 题解
IuMgXnWu
04-20 223
文章目录Network of Schools POJ - 1236 Network of Schools POJ - 1236 给你一个有向图，从一个点出发可以到达很多点，问你至少从几个点出发，可以遍历所有的点，以及，至少添加几条变可以从任何一个点到达其他点 首先，我们先缩点，这样处理起来会比较方便，得到一个 有向无环图 。然后我们分析一下，对于任何一个有入度的点，必然有一条路到达这个点，换句话说...
【数字_ID】CUC-SpringTraining-16
IuMgXnWu
04-29 256
文章目录HDU3062PartyPOJ3683Wormholes 虫洞 HYSBZ - 1715糖果 HYSBZ - 2330POJ 1364 KingHDU 2063 过山车Asteroids POJ - 3041 HDU3062Party #include <iostream> #include <string> #include <stack> #incl...
Spring Cloud Alibaba组件的一些笔记
m0_51307378的博客
07-05 86
通过nacos，每次当你需要调用其他服务的时候，就回去nacos的注册中心通过名字查询对应服务的端口号和ip地址，然后再去调用该服务，这时候就跟nacos没有任何关系了，nacos就算挂掉，只要服务的ip地址和端口号没有改变，都不会有任何影响。如果服务的IP地址或者端口号进行了改变，则当该服务重新启动时，就会在nacos注册中心将信息重新注册。RestTemplate 可以调用其他服务的方法，但是如果别的服务更改了端口，你调用的链接也要更改端口，如果是服务器的ip地址更改了，又要更改对应的链接的ip地址。
数据压缩_任务五_预测误差均方值推导及最小二乘法
weixin_41821317的博客
05-17 1899
文章目录预测误差均方值推导及最小二乘法解法总结一、预测误差均方值最小值推导二、最小二乘法总结1、最小二乘法2、梯度下降法（1）原理（2）算法过程（3）存在问题3、牛顿法（1）原理与梯度下降法比较：（2）算法过程（3）存在问题4、高斯牛顿法 预测误差均方值推导及最小二乘法解法总结 一、预测误差均方值最小值推导 二、最小二乘法总结 1、最小二乘法 最小二乘法（英语：least squares method），又称最小平方法，是一种数学优化方法。它通过最小化误差的平方和寻找数据的最佳函数匹配。 利用最小二乘法可
选择Spring集成好的Spring Cloud Zuul方便更快
热门推荐
xiaofeiyuh的博客
07-29 1万+
上一篇简单说了SpringCloud与Eureka的集成。主要解决了微服务间的服务注册及调用的问题。这一篇集成Zuul，而后结合SpringCloud、Eureka、Zuul环境下进行真实系统联调，帮助更好的对这些组件的理解。毕竟，实战才是学习最快的方法。 一、聊聊网关 上篇也提到过，微服务下，各个业务模块都被拆分成相互独立的微服务。虽然注册中心（如Eureka）解决了服务内部的注册发现、健康检查等问题。但是如何与外部服务进行通信又是一个新的问题了。 举个栗子 某初创公司，刚刚经历了一次大的架构改革。将原有
数字视频处理_c++读入cif文件并操作
weixin_41821317的博客
03-14 585
C++读入cif文件
国家地区数字币种
Mr.薛的博客
06-18 7653
国家名称 国家 中文货币名称 货币 字母代码 数字代码 小单位 阿富汗 AFGHANISTAN 阿富汗 Afghani AFN 971 2 奥兰群岛 ÅLAND ISLANDS 欧元 Euro EUR 978 2 阿尔巴尼亚 ALBANIA 莱克 Lek ALL 8 2 阿尔及利亚 ALGERIA 阿尔及利亚丁那 Algerian Dinar DZD 12 2 美属...
XJ_CUC_NSB负载均衡测量2019年.docx
10-11
- **应急参数提前部署**：提出了多种应急措施，如减小低负荷邻区的小区偏置，增大高负荷小区的最小接入电平等[^4^]。 #### **3. 5G网络优化** 文档三至文档十二涵盖了多个5G网络优化的案例和策略。主要内容如下： ...
cuc-spring-tomcat7-template:初始发布
06-29
用法 cp project.samples .project import into eclipse project run with tomcat 7 (!!!不支持tomcat 8 !!!) 访问 localhost:8080// 为 json 访问 localhost:8080//hello.jsp 为 jsp 页面 更新 ...
cuc_ieschool.flv
08-03
音视频开发需要用到flv视频作为测试视频，flv是H264通过解码后所产生的视频格式，配合ffmpeg和其他音视频开发程序，可以开发相应内容
java_springboot校内兼职信息管理系统_毕业论文.docx
最新发布
11-11
java_springboot校内兼职信息管理系统_毕业论文.docx
com.harmonyosnext.exception.AIModelLoadingException.md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
高校校园点餐系统.zip
11-11
该毕业设计源码基于Maven构建，采用JSPS+SSM（Spring+Spring MVC+MyBatis）框架，实现了一个可扩展的Web应用项目，适合学习和快速搭建Web项目的开发者使用。
基于SpringBoot + Vue的前后端分离电影售票及影院管理系统源码+数据库（Java毕业设计）
11-11
基于SpringBoot + Vue的前后端分离电影售票及影院管理系统源码+数据库（Java毕业设计），个人大四的毕业设计、经导师指导并认可通过的高分设计项目，评审分98.5分。主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也可作为课程设计、期末大作业。 基于SpringBoot + Vue的前后端分离电影售票及影院管理系统源码+数据库（Java毕业设计）基于SpringBoot + Vue的前后端分离电影售票及影院管理系统源码+数据库（Java毕业设计）基于SpringBoot + Vue的前后端分离电影售票及影院管理系统源码+数据库（Java毕业设计）基于SpringBoot + Vue的前后端分离电影售票及影院管理系统源码+数据库（Java毕业设计）基于SpringBoot + Vue的前后端分离电影售票及影院管理系统源码+数据库（Java毕业设计）基于SpringBoot + Vue的前后端分离电影售票及影院管理系统源码+数据库（Java毕业设计）基于SpringBoot + Vue的前后端分离电影售票及影院管理系统源码+数据库（Java毕业设计）基于S
全球PCB用电解铜箔市场：7.83%的年复合增长率引领电子材料新时代
11-11
全球PCB用电解铜箔市场：7.83%的年复合增长率引领电子材料新时代 在科技日新月异的今天，铜箔作为一种关键的电子材料，正以其独特的导电性能和广泛的应用领域，成为推动全球电子工业发展的重要力量。特别是电解铜箔，作为印刷电路板（PCB）的核心材料，正迎来前所未有的市场增长机遇。随着数据中心、云计算、半导体封装、人工智能等领域的快速发展，高质量电解铜箔的需求持续攀升。然而，在这样一个充满机遇与挑战的市场中，如何准确把握市场动态，充分利用技术创新，成为每一位行业参与者必须面对的问题。本文将深入探讨全球PCB用电解铜箔市场的现状、驱动因素与未来发展趋势，为您揭示这一市场的无限潜力。 市场概况： 全球PCB用电解铜箔市场在2023年展现出了强劲的增长势头，市场价值达到了56.6亿美元。据预测，这一市场将在2030年突破96.4亿美元大关，期间复合年增长率高达7.83%。这一数据无疑揭示了电解铜箔市场的巨大潜力和广阔前景。从地区分布来看，亚太地区凭借其庞大的电子产业基础和快速的技术创新，占据了市场的最大份额。预计在未来几年内，亚太地区将继续保持其领先地位，市场规模将从2024年的411.05万吨增
【Unity双摇杆射击游戏工具包】Twicks - Twin Stick Shooter Kit 适合用来做各种动作和射击类游戏
11-11
文件名：Twicks - Twin Stick Shooter Kit.unitypackage Twicks - Twin Stick Shooter Kit 是一个 Unity 插件，专门用于创建双摇杆射击游戏的工具包。它可以帮助开发者快速构建双摇杆射击游戏的核心功能，适合用来做各种动作类和射击类游戏。这里是它的主要功能和特点： 1. 预制组件与场景 插件提供了一系列预制角色、敌人、武器和特效，可以直接拖拽到场景中使用，节省了重复搭建基础场景的时间。 预设的敌人 AI 和角色控制机制让开发者可以轻松开始游戏的主要逻辑开发，而无需从零开始设计基本的角色互动和敌人行为。 2. 双摇杆控制系统 内置了双摇杆控制系统，支持移动和射击的双摇杆操作。这个控制方案非常适合游戏手柄、键盘+鼠标，甚至移动设备的触控操作。 灵活的自定义设置可以适应各种操作设备，让游戏可以在多个平台上运行。 3. 基础射击和战斗系统 拥有灵活的武器系统，支持多种射击模式和武器切换，包括子弹、激光等不同类型的射击效果。 可以调节武器的射速、射程、弹药类型等参数，还支持武器升级和自定义。 ......
mysql 这个sql有问题吗？ if (select COUNT(1) num from ccs_archive_company where street_no =(select street_no from ccs_archive_company cac where equipment_id ='A5C330113A34041012316550'))=1 then INSERT INTO ccs_user_company (company_id,user_Id,equipment_id) select t1.id,t2.user_id,t1.equipment_id from ccs_archive_company t1 inner join (select user_Id ,COUNT(DISTINCT equipment_id) from ccs_user_company cuc where equipment_id in (select equipment_id from ccs_archive_company where district_no = (select district_no from ccs_archive_company where equipment_id = 'A5C330113A34041012316550') and equipment_id != 'A5C330113A34041012316550') group by user_Id having COUNT(distinct equipment_id)= (select count(distinct equipment_id)-1 from ccs_archive_company where district_no = (select district_no from ccs_archive_company where equipment_id = 'A5C330113A34041012316550'))) t2 where t1.equipment_id = 'A5C330113A34041012316550' end if
07-16
从语法上看，你提供的 SQL 语句没有明显的语法错误。然而，由于这是一个复杂的查询语句，我无法判断它的逻辑是否符合你的业务需求。你需要确保查询中的表、字段、条件和连接都是正确的，并且符合你的预期结果。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值