neuq周报

最新推荐文章于 2024-09-14 22:34:12 发布
最新推荐文章于 2024-09-14 22:34:12 发布
阅读量752 收藏 21
点赞数 20
文章标签： 图论 算法 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75423771/article/details/134913050
版权

P4779 【模板】单源最短路径（标准版）

思路：图论，优先队列

#include <bits/stdc++.h>
using namespace std;
int n, m, s, ans[100005];
bool vis[100005];
struct node{
    int u, v;
    bool operator<(const node& d) const{
        return v > d.v;
    }
    bool operator>(const node& d) const{
        return v < d.v;
    }
};
vector<node> vec[100005];
priority_queue<node, vector<node> > q;
int main(){
    scanf("%d %d %d", &n, &m, &s);
    for(int i = 0; i < m; i++){
        int a, b, c;
        scanf("%d %d %d", &a, &b, &c);
        node d{b, c};
        vec[a].push_back(d);
    }
    for(int i = 1; i <= n; i++){
        ans[i] = 0x3f3f3f3f;
    }
    ans[s] = 0;
    node d{s, 0};
    q.push(d);
    while(!q.empty()){
        node cur = q.top();
        q.pop();
        if(vis[cur.u]) continue;
        vis[cur.u] = true;
        for(int i = 0; i < vec[cur.u].size(); i++){
            if(ans[vec[cur.u][i].u] > ans[cur.u] + vec[cur.u][i].v){
                ans[vec[cur.u][i].u] = ans[cur.u] + vec[cur.u][i].v;
                node tmp = {vec[cur.u][i].u, ans[vec[cur.u][i].u]};
                q.push(tmp);
            }
        }
    } 
    for(int i = 1; i <= n; i++){
        printf("%d ", ans[i]);
    }
    return 0;
}
B3647 【模板】Floyd

思路：最短路

#include <bits/stdc++.h>
#define inf  0x3f3f3f3f
using namespace std;
int Map[105][105];
int main()
{
    int n,m,u,v,w;
 
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            {
                if(i==j)
                    Map[i][j]=0;
                else
                    Map[i][j]=inf;
            }
 
    while(m--)
    {
        scanf("%d%d%d",&u,&v,&w);
        Map[u][v]=min(Map[u][v],w);
        Map[v][u]=Map[u][v]; 
    }
 
    int i,j,k;
 
    for(k=1;k<=n;k++)
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                if(Map[i][j]>Map[i][k]+Map[k][j])
                    Map[i][j]=Map[i][k]+Map[k][j];
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=n;j++)
        {
            printf("%d ",Map[i][j]);
        }
        printf("\n");
    }
 
    return 0;
}

P2661 [NOIP2015 提高组] 信息传递

思路：图论

#include <bits/stdc++.h>
using namespace std;
 
const int Max=200005;
int n,m,size,Index,cnt,tot,ans=1e9;
int num[Max],low[Max],sum[Max],p[Max<<1],vis[Max],first[Max]; 
struct shu{int to,next;};
shu edge[Max];
 
inline int get_int()
{
    int x=0,f=1;
    char c;
    for(c=getchar();(!isdigit(c))&&(c!='-');c=getchar());
    if(c=='-') f=-1,c=getchar();
    for(;isdigit(c);c=getchar()) x=(x<<3)+(x<<1)+c-'0';
    return x*f;
}
 
inline void build(int x,int y)
{
    edge[++size].next=first[x];
    first[x]=size;
    edge[size].to=y;
}
 
inline void tarjan(int point)
{
    num[point]=low[point]=++Index;
    p[++tot]=point,vis[point]=1;
    for(int u=first[point];u;u=edge[u].next)
    {
      int to=edge[u].to;
      if(!num[to]) tarjan(to),low[point]=min(low[point],low[to]);
      else if(vis[to]) low[point]=min(low[point],num[to]);
    }
    if(low[point]==num[point])
    {
      cnt++;
      while(1)
      {
          int x=p[tot--];
          sum[cnt]++;
          vis[x]=0;
          if(x==point) break;
      }
    }
}
 
int main()
{
    n=get_int();
    for(int i=1;i<=n;i++) build(i,get_int());
    for(int i=1;i<=n;i++) if(!num[i]) tarjan(i);
    for(int i=1;i<=cnt;i++) if(sum[i]!=1) ans=min(ans,sum[i]);
    cout<<ans<<"\n";
    return 0;
}

P1144 最短路计数

思路：图论

#include<bits/stdc++.h>
 
using namespace std;
const int MAXN=1e6+8;
int head[MAXN],num,s=1;
int n,m,dis[MAXN],cnt[MAXN]; 
struct edge
{
    int to,next;
}e[MAXN*2];
struct node
{
    int x,dis;
    bool operator<(node a)const
    {
        return dis>a.dis;
    } 
};
priority_queue<node> q; 
void add(int u,int v)
{
    e[++num].to=v;
    e[num].next=head[u];
    head[u]=num;
}
void dijkstra()
{
    memset(dis,0x3f3f3f3f,sizeof dis);
    dis[s]=0;
    q.push((node){s,0});
    cnt[1]=1;
    while(!q.empty())
    {
        int u=q.top().x;
        q.pop();
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(dis[v]>dis[u]+1)
            {
                dis[v]=dis[u]+1;
                q.push((node){v,dis[v]});
                cnt[v]=cnt[u]%100003;
            }
            else if(dis[v]==dis[u]+1)
            {
                cnt[v]=(cnt[u]+cnt[v])%100003;    
            }
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1,u,v;i<=m;i++)
    {
        cin>>u>>v;
        add(u,v);
        add(v,u);
    }
    dijkstra();
    for(int i=1;i<=n;i++)    cout<<cnt[i]<<endl;
    return 0;
}

P8794 [蓝桥杯 2022 国 A] 环境治理

思路：二分，最短路

#include<bits/stdc++.h>
using namespace std;
#define N 105
#define int long long
#define INF 0x3f3f3f3f3f3f3f3f
#define mid (l + r >> 1)
int n, Q, l, r, ans = INF;
int D[N][N], L[N][N], dis[N][N], reduce[N];
inline int check(int x) {
    int t = x / n, P = 0;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) 
            dis[i][j] = INF;
    for (int i = 1; i <= n; i++) 
        dis[i][i] = 0;
    for (int i = 1; i <= n; i++)
        reduce[i] = t;
    for (int i = 1; i <= x - n * t; i++)
        ++reduce[i];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) 
            dis[i][j] = max(L[i][j], D[i][j] - reduce[i] - reduce[j]);//与每条道路都有的一个灰尘度的下限值比较取最小值
    for(int k=1;k<=n;k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++) 
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            P += dis[i][j];
    if (P <= Q) return 1;
    else return 0;
}
 
signed main() {
    cin >> n >> Q;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            cin >> D[i][j];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            cin >> L[i][j];
    l = 0, r = INF;
    while (l <= r) {
        if (check(mid)) ans = min(ans, mid), r = mid - 1;
        else l = mid + 1;
    }
    if (ans == INF) printf("-1");
    else printf("%lld", ans);
    return 0;
}

P3367 【模板】并查集

思路：并查集

#include<bits/stdc++.h>
using  namespace std;
const int MAXcount = 100000;
int par[MAXcount],height[MAXcount];
//par[i]表示i结点的父结点 “par[i]=-1”表示为根结点
//height[i]表示以i为根结点的树的结点个数
int Find(int x)//返回x的父亲结点
{
    int ini = x;
    while(1){
        if(par[x]==-1){
            //朴素
//            return x;
            break;
        }
        x=par[x];
    }
    //优化--路径压缩，再重复一次查找根结点操作，
    //每查找完一次父亲结点，
    //就将该结点的父亲par[]设置为该树的根结点
    //（也就是上一次循环查找到的x）
    while(1){
        if(par[ini]==-1){
            break;;
        }
        int zj = ini;
        ini=par[ini];
        par[zj]=x;
    }
    return x;
}
void Union(int x,int y)
{
    int rootx,rooty;
    rootx=Find(x);rooty=Find(y);
    if(rootx!=rooty){//如果根结点不同，进行合并操作
        //朴素--从x和y集合的根结点中随机选取一个作为另一个集合的根结点，完成合并操作
//        par[rooty]=par[rootx];
        //优化--选择树高小的合并到树高（集合的结点个数）大的根结点下
        if(height[rooty]>=height[rootx]){//如果y集合的结点数大于x集合的结点数，则将x集合合并到y结合的根结点下
            par[rootx]=rooty;
            height[rooty]+=height[rootx];//同时更新树高
        }else{
            par[rooty]=rootx;
            height[rootx]+=height[rooty];
        }
    }
}

int main()
{
    int N,M;
    memset(par,-1,sizeof(par));//初始化为-1，每个结点刚开始都是一个集合，所以其父结点为-1，表示其为根结点
    memset(height, 0, sizeof(height));//初始化数组为0
    cin>>N>>M;
    for(int i=0;i<M;i++){
        int z,x,y;
        cin>>z>>x>>y;
        if(z==1){
            Union(x,y);//合并集合x和y
        }else{
            int roox=Find(x);//查找x结点的父亲结点
            int rooy=Find(y);//查找y结点的父亲结点
            if(roox==rooy)cout<<"Y"<<endl;//比较两结点的父亲结点是否相同，可知是否在同一集合之中
            else cout<<"N"<<endl;
        }
    }
}
 

P8604 [蓝桥杯 2013 国 C] 危险系数

思路：图论

#include<iostream>
#include<vector>
#define int long long
 
using namespace std;
 
vector<int>edges[1010];//临接表存储图
vector<bool>visited(1010);//记录是否走过
vector<int>vexnum(1010);//记录每个点走过次数
int n, m, start, endd, ans = 0, sum = 0;
 
void dfs(int cur) {
    if (cur == endd) {
        sum++;//路径总数
        for (int i = 1; i <= n; i++) {
            if (visited[i]==1) {
                vexnum[i]++;//每个点走过次数
            }
        }
    }
    else {
        int len = edges[cur].size();
        for (int i = 0; i < len; i++) {
            int value = edges[cur][i];
            if (!visited[value]) {
                visited[value] = 1;
                dfs(value);
                visited[value] = 0;
            }
        }
    }
}
 
 
signed main()
{
    cin >> n >> m;
    int v1, v2, len;
    for (int i = 0; i < m; i++) {
        cin >> v1 >> v2;
        edges[v1].push_back(v2);
        edges[v2].push_back(v1);
    }
    cin >> start >> endd;
    visited[start] = 1;
    dfs(start);
    if (sum > 0) {
        for (int i = 1; i <= n; i++) {
            if (vexnum[i] == sum) {//是否存在点走过次数与路径总数相等的点
                ans++;//关键点计数
            }
        }
        cout << ans - 2 << endl;//减2是因为统计时多加了起点和终点
    }
    else {
        cout << "-1" << endl;
    }
    return 0;
}

P1330 封锁阳光大学

思路：图论

#include <bits/stdc++.h>
using namespace std;
const int maxv=1e4+10;
const int maxe=1e5+10;
 
inline int read(){
    int x=0,f=1;char ch;
    do{ch=getchar();if(ch=='-')f=-1;}while(!isdigit(ch));
    do{x=x*10+ch-'0';ch=getchar();}while(isdigit(ch));
    return f*x;
}
 
struct node{
    int nxt,to;
}e[maxe<<1];
int tot=1,head[maxv];
int n,m,ans,sum[2];
bool vis[maxv],cor[maxv];
 
inline void add_edge(int from,int to){
    e[++tot]=node{head[from],to},head[from]=tot;
}
 
void read_and_parse(){
    n=read(),m=read();
    for(int i=1;i<=m;i++){
        int from=read(),to=read();
        add_edge(from,to),add_edge(to,from);
    }
}
 
bool dfs(int u,int c){
    if(vis[u])return cor[u]==c;
    vis[u]=1,++sum[cor[u]=c];
    for(int i=head[u];i;i=e[i].nxt)if(!dfs(e[i].to,c^1))return 0;
    return 1;
}
 
void solve(){
    for(int i=1;i<=n;i++)if(!cor[i]){
        sum[0]=sum[1]=0;
        if(!dfs(i,0)){puts("Impossible");return;}
        ans+=min(sum[0],sum[1]);
    }
    printf("%d\n",ans);
}
 
int main(){
    read_and_parse();
    solve();
    return 0;
}

P3916 图的遍历

思路：图论

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#define  Max 100005
using namespace std;
vector<int > Graph[Max];
int flag[Max];
void  dfs(int v,int t);
int a[Max];
int main()
{
    int n,m,v1,v2;
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>v1>>v2;
        Graph[v2].push_back(v1);
    }
    memset(flag, false, sizeof(flag));
    int v;
    for(int i=n;i;i--)
    {
        if(!flag[i])
        {
            dfs(i,i);
        }
    }
    for(int i=1;i<=n;i++)
    {
        cout<<a[i]<<" ";
    }
    return 0;
}

void  dfs(int v,int t)
{
    flag[v]=true;
    a[v]=t; //遍历所有当前能达到的点
    for(int i=0;i<Graph[v].size();i++)
    {
        if(!flag[Graph[v][i]])
        {
            dfs(Graph[v][i],t);
        }
    }
}
 

P1119 灾后重建

思路：图论

#include <bits/stdc++.h>
using namespace std;
 
int M,N,Q;
int t[205];  //存储重建时间
int dist[205][205];  //存公路长度
 
 
void floyd(int k)   //以前k个村庄为中转点进行dp
{
    for(int i = 0; i < N; i ++)
    {
        for(int j = 0; j < N; j ++)
        {
            dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
        }
    }
    
    return;
}
 
int main()
{
    cin >> N >> M;  //村庄数和公路数
    for(int i = 0; i < N; i ++) cin >> t[i];
    
    for(int i = 0; i < N; i ++)
    {
        for(int j = 0 ;j < N; j ++)
        if(i != j)dist[i][j]=0x3f3f3f; //给两个村庄之间的边长初始化成无穷大
    }
    
    for(int i = 0; i < M; i ++) //用邻接矩阵来存边
    {
        int a,b,c;
        cin >> a >> b >> c;
        dist[a][b] = c;
        dist[b][a] = c;
    }
    
    cin >> Q;  //询问次数
    int temp = 0; //代表能访问到的序号最大的村庄
    for(int i = 1; i <= Q; i ++)
    {
        int a,b,c;
        cin >> a >> b >> c;
        while(temp < N && t[temp] <= c) //如果这天村庄已经重建好了，并且村庄序号没有越界
        {
            floyd(temp++);  //以前temp个村庄作为中转点
        }
        
        if(c < t[a] || c < t[b]) cout << -1;   //没重建好直接GG
        else if(dist[a][b] == 0x3f3f3f) cout << -1;  //两村庄不连通也直接GG
        else cout << dist[a][b];
        
        if(i != Q) cout << endl;
    }
    return 0;
}

2201_75423771
关注
neuq_BigDiffRobot
03-01
【neuq_BigDiffRobot】项目是一个基于Python的智能机器人框架，主要目的是为了实现大规模数据差异比较和处理。在数据分析、数据治理以及自动化测试等领域，这个框架能提供高效、精准的数据对比功能，有助于找出数据...
NEUQ-STC16F例程及主板原理图.zip
01-31
《NEUQ-STC16F例程及主板原理图》是针对嵌入式硬件领域，特别是单片机编程和应用的学习资源。该压缩包包含了两个主要文件：STC16F主板原理图.pdf和NEUQ_STC16F40K128_DEMO - SmartCar.zip。这份资料特别适合对STC16F...
Neuq周报
2201_75423771的博客
12-17 888
思路：图论，贪心struct zf{ //再带权情况下用结构体便于排序int x;int y;int z;}a[100005];//记录每个犯人的第一个敌人bool cmp(zf c,zf d){ //以仇恨值排序return x;}else{if(k!=l) f[k]=l;
NEUQ周报
holazoe的博客
12-17 376
【代码】NEUQ周报。
NEUQ-ACM周报6
holazoe的博客
11-19 42
【代码】NEUQ-ACM周报6。
NEUQ-ACM周报4
holazoe的博客
11-05 53
是dp，但只能通过一半......
NEUQ-ACM周报3
holazoe的博客
10-29 54
dp动态规划，把前三项的数定好后，例如6/2=3，那就在原有的2(1,6||6)的基础上加上由2到3的所有数。动态规划，把前两项规定好后，其他依次叠加即可。
NEUQ-ACM周报（最短路径）
holazoe的博客
12-10 372
假设现在有6个点，那我们从点2到点6怎么走路程最短呢，假设我们知道从点 2 到点 4 再到点 5 再到点 6 这样走路程最短，然后从点 2 直接到点 6 路程次之，其实最短的路线逻辑就是从点2再到中间节点 5 再到点 6，只不过在之前的遍历中已经储存了从点 2 到点 5 怎么走路程最短这一信息了。这样，当算法考虑到节点 6 的时候，它会利用已知的最短路径信息，包括从节点 2 到节点 5 的最短路径，以找到从节点 2 到节点 6 的最短路径。直接路径是无穷大，而通过 A 的路径是 2 + 5 = 7。
neuq-acm预备队训练week 8 周报
ciwen_的博客
12-11 155
neuq-acm预备队训练week 8 B3647 【模板】Floyd 题解-CSDN博客neuq-acm预备队训练week 8 P4779 【模板】单源最短路径（标准版）-CSDN博客neuq-acm预备队训练week 8 P2661 [NOIP2015 提高组] 信息传递-CSDN博客neuq-acm预备队训练week 8 P1144 最短路计数-CSDN博客neuq-acm预备队训练week 8 P8794 [蓝桥杯 2022 国 A] 环境治理-CSDN博客neuq-acm预备队训练week 8 P
neuq-acm预备队训练week 9 周报
ciwen_的博客
12-17 113
neuq-acm预备队训练week 9 P3367 【模板】并查集-CSDN博客neuq-acm预备队训练week 9 P8604 [蓝桥杯 2013 国 C] 危险系数-CSDN博客neuq-acm预备队训练week 9 P1330 封锁阳光大学-CSDN博客neuq-acm预备队训练week 9 P3916 图的遍历-CSDN博客neuq-acm预备队训练week 9 P1119 灾后重建-CSDN博客
neuq-acm预备队训练week 6 周报
ciwen_的博客
11-20 115
neuq-acm预备队训练week 6 P1135 奇怪的电梯-CSDN博客neuq-acm预备队训练week 6 P1443 马的遍历-CSDN博客neuq-acm预备队训练week 6 P3958 [NOIP2017 提高组] 奶酪-CSDN博客neuq-acm预备队训练week 6 P1162 填涂颜色-CSDN博客
十八届智能车急速越野-陀螺仪姿态解算 from:NEUQ
08-01
【作品名称】：十八届智能车急速越野--陀螺仪姿态解算 from:NEUQ 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： get...
NEUQ-ACM预备队蓝桥杯题解提交处.zip
01-24
教育部认可的大学生竞赛备赛资料代码，源码，竞赛总结，所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通 全国电子设计大赛、全国大学生智能汽车竞赛、蓝桥杯、集成电路...
Henrik-Yao#NEUQ-ACM-Solution#题解23
07-25
题解先设置一个字符组，将字符存入，设置一个大循环，对于每一次输入的字符组将其存入，依次和原字符组进行比较，最后统计相同即可。long long ans(long
代码随想录训练营 Day60打卡 图论part10 SPFA算法 Bellman-Ford 之判断负权回路 Bellman-Ford 之单源有限最短路
qq_42952637的博客
09-14 847
代码随想录训练营 Day60打卡 图论part10 SPFA算法 Bellman-Ford 之判断负权回路 Bellman-Ford 之单源有限最短路
代码随想录算法训练营第62天| 图论 Floyd算法 A*算法
meiqiuxiaohei的博客
09-11 328
dp[i][j][k]意思是从节点 i 到节点 j 考虑节点1-k为中转节点时所能求得的最短路径，接着是确认递推公式，节点 i 到节点 j 考虑节点1-k为中转节点时所能求得的最短路径有两种方式有两种可能，第一种是从节点 i 到节点 j 的最短路径不过节点 k ，另一种是从节点 i 到节点 j 的最短路径经过节点 k。使用优先级队列可以让每次的队头元素都存储的是距离最近的点。最短路径可能是经过节点1-k中的节点，每次增加一个节点进行考虑，将中转节点有k的情况加入考虑之后节点i到节点j的距离。
【代码随想录训练营第42期 Day58打卡 - 图论Part8 - 拓扑排序
最新发布
记得要努力变强
09-14 1013
拓扑排序
计算左边（比自己小的元素）的最长距离
wniuniu_的博客
09-14 99
前言：一般做的题目都是使用单调栈来求出距离这个点最近的那个比这个数大或小的元素，但是如果是需要找到最远的那个元素呢？我们可以用到类似逆序对的思路，我们先进行排序从小到大，接着我们先处理左边，每次维护一个最小的下标。
STC16F单片机GPIO、PWM与编码器详解
STC16F单片机基础模块讲义深入剖析了单片机中的关键知识点，以这款嵌入式硬件平台为例，主要涵盖了以下几个核心部分： 1. GPIO (通用输入输出) GPIO是单片机中极其重要的功能模块，它允许用户灵活地配置引脚作为...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值