新生专题三(图论)

最新推荐文章于 2022-05-23 18:40:05 发布
最新推荐文章于 2022-05-23 18:40:05 发布
阅读量261 收藏
点赞数
分类专栏： acm培训 文章标签： 图论基础 最短路问题 最小生成树 拓扑排序 并查集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40379678/article/details/79322501
版权

知识点:最短路问题, 最小生成树, 拓扑排序, 并查集等.

题目链接: 点击打开链接

一.Good Luck in CET-4 Everybody!(HDU1847)

这道题我一看是博弈论,一脸懵逼,说好的图论,,,,,,我是找规律过的反正.
百度下来叫巴什博弈, 就是三的倍数先手稳输. 
#include <cstdio>

int main()
{
    int n;
    while(scanf("%d", &n) != EOF)
    {
        if(n % 3){
            printf("Kiki\n");
        }
        else{
            printf("Cici\n");
        }
    }

    return 0;
}

二.Highways(POJ1751)

最小生成树.Kruskal算法.(百度了一下,Prim也有人写,  但是可能超时)

我是套的牛客网讲课学长给的板子.

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
//MAXN是最大点数，MAXM是最大边数
const int MAXN=4000;//一开始小了RE了，一怒之下开这么大
const int MAXM=500000;
int F[MAXN];//并查集
struct Edge
{
    int u,v,w;
} edge[MAXM];///存路
int tol;//边的总数
void addedge(int u,int v,int w)
{
    edge[tol].u=u;
    edge[tol].v=v;
    edge[tol++].w=w;
}
bool cmp(Edge a,Edge b)
{
    return a.w<b.w;
}
int find(int x)
{
    if(F[x]==-1)return x;
    else return F[x]=find(F[x]);//路径压缩
}

///用并查集来维护已经连起来的关系。
int Kruskal(int n)
{
    memset(F,-1,sizeof(F));
    sort(edge,edge+tol,cmp);///对路排序
    int cnt=0;///cnt是计数已经选了的路
    int ans=0;
    for(int i=0; i<tol; i++)
    {
        int u=edge[i].u;
        int v=edge[i].v;
        int w=edge[i].w;
        int t1=find(u);
        int t2=find(v);
        if(t1!=t2)
        {  //最大的一条边
            ans=max(ans,w);
            F[t1]=t2;
            cnt++;
        }
        if(cnt==n-1)break;
    }
    if(cnt<n-1)return -1;
    else return ans;
}
int main()
{
    int n;
    int T;
    scanf("%d", &T);

    while(T--)
    {
        scanf("%d",&n);
        memset(edge,0,sizeof(edge));
        tol=0;
        for (int i=0; i<n; i++)
        {
            int u = i, v, w;
            for(int j = 0; j < n; j++)
            {
                v = j;
                scanf("%d", &w);
                if(w){///输入跳过0
                    addedge(u,v,w);
                }
            }
        }

        int ans=Kruskal(n);
        printf("%d\n",ans);

    }

    return 0;
}

三.Connect the Cities(HDU3371)


我Kruskal 和 Prim 都写了, 都超时了.百度了一个980ms的代码, 数据至于卡这么死吗.

#include <cstdio>
#include <cstring>
using namespace std;
#define MAXN 505
#define INF 10000000
bool vis[MAXN];
int lowc[MAXN];
int n, m, k;
int maps[MAXN][MAXN];

int prim()
{
    int ans = 0;
    memset(vis, false, sizeof vis);
    vis[1] = true;

    for(int i = 1; i <= n; i++)
        lowc[i] = maps[1][i];

    for(int i = 2; i <= n; i++){
        int minc = INF;
        int p = -1;
        for(int j = 1; j <= n; j++)
            if(!vis[j] && minc>lowc[j])
        {
            minc = lowc[j];
            p = j;
        }

        if(minc >= INF)
            return -1;

        ans += minc;

        vis[p] = true;

        for(int j = 1; j <= n; j++){
            if(!vis[j] && lowc[j] > maps[p][j])
                lowc[j] = maps[p][j];
        }
    }

    return ans;
}

int main()
{
    int T;
    scanf("%d", &T);

    while(T--)
    {
        scanf("%d%d%d", &n, &m, &k);
        memset(maps, 0x3f, sizeof maps);

        for(int i = 1; i <= m; i++){
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            if(maps[u][v] > w)
            maps[u][v] = maps[v][u] = w;
        }

        for(int i = 1; i <= k; i++){
            int t, a[MAXN];
            scanf("%d", &t);
            for(int j = 1; j <= t; j++)
                scanf("%d", &a[j]);
            for(int j = 1; j <= t; j++)
                for(int l = 1; l <= t; l++)
                    maps[a[j]][a[l]] = 0;
        }

        printf("%d\n", prim());
    }

    return 0;
}

/**
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=505;
const int Max=0x3f3f3f3f;
int map[maxn][maxn],low[maxn],visit[maxn];
int n,m,k;
void prim()
{
    int i,j,pos,min,mst=0;
    memset(visit,0,sizeof(visit));
    pos=1;
    visit[1]=1;
    for(i=1;i<=n;i++)
        low[i]=map[pos][i];
    for(i=1;i<n;i++)
    {
        min=Max;
        for(j=1;j<=n;j++)//更新min的值
        {
            if(!visit[j] && min>low[j])
            {
                min=low[j];
                pos=j;
            }
        }
        mst+=min;
        if(mst>=Max) break;//说明这个图不连通
        visit[pos]=j;
        for(j=1;j<=n;j++)
        {
            if(!visit[j] && low[j]>map[pos][j])//更新low数组
                low[j]=map[pos][j];
        }
    }
    if(mst>=Max)
        printf("-1\n");
    else
        printf("%d\n",mst);
}
int main()
{
    int t,i,j,x;
    int p,q,c;
    int a[101];
    scanf("%d",&t);
    while(t--)
    {
        memset(map,Max,sizeof(map));
        scanf("%d%d%d",&n,&m,&k);
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&p,&q,&c);
            if(map[p][q]>c)//这里也要注意一下，题目没说有重边，但是数据里面有，没加这个就wa
            map[p][q]=map[q][p]=c;
        }
        while(k--)//处理已连接的边，把权值赋0；
        {
            scanf("%d",&x);
            for(i=1;i<=x;i++)
                scanf("%d",&a[i]);
            for(i=1;i<=x;i++)
                for(j=1;j<=x;j++)
                    map[a[i]][a[j]]=0;
        }
       prim();
    }
    return 0;
}
*/


/**
#include <cstdio>
#include <algorithm>
using namespace std;
#define MAXN 505
#define MAXM 25005
int father[MAXN];
int rak[MAXN];
struct Edge{
  int u, v, w;
}edge[MAXM];
int tol;
int cnt;

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

bool cmp(Edge a, Edge b)
{
    return a.w < b.w;
}

void init(int n)
{
    for(int i = 0; i <= n; i++){
        father[i] = i;
        rak[i] = 0;
    }
}

int findfa(int x)
{
    if(father[x] = x) return x;
    else return father[x] = findfa(father[x]);
}

void unite(int x, int y)
{
    x = findfa(x);
    y = findfa(y);

    if(x != y)
        cnt++;

    if(rak[x] < rak[y])
        father[x] = y;
    else{
        father[y] = x;
        if(rak[x] == rak[y])
            rak[x]++;
    }
}

int Kruskal(int n)
{
    sort(edge, edge + tol, cmp);
    int ans = 0;

    for(int i = 0; i < tol; i++){
        int rot1 = findfa(edge[i].u);
        int rot2 = findfa(edge[i].v);
        if(rot1 != rot2){
            ans += edge[i].w;
            unite(rot1, rot2);
        }
        if(cnt == n - 1)
            break;
    }
    if(cnt < n - 1) return -1;
    else return ans;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        int n, m, k;
        scanf("%d%d%d", &n, &m, &k);
        tol = 0;

        for(int i = 0; i < m; i++){
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            addedge(u, v, w);
        }

        init(n);
        cnt = 0;
        for(int i = 0; i < k; i++){
            int t, l;
            scanf("%d%d", &t, &l);

            for(int j = 1; j < t; j++){
                int z;
                scanf("%d", &z);
                unite(l, z);
            }
        }

        sort(edge, edge + m, cmp);

        printf("%d\n", Kruskal(n));
    }

    return 0;
}
*/
/*
#include <cstdio>
#include <algorithm>
using namespace std;
#define MAXN 505
#define MAXM 25005
int father[MAXN];
int rak[MAXN];
struct Edge{
  int u, v, w;
}edge[MAXM];
int tol;
int cnt;

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

bool cmp(Edge a, Edge b)
{
    return a.w < b.w;
}

void init(int n)
{
    for(int i = 0; i <= n; i++){
        father[i] = i;
        rak[i] = 0;
    }
}

int findfa(int x)
{
    if(father[x] = x) return x;
    else return father[x] = findfa(father[x]);
}

void unite(int x, int y)
{
    x = findfa(x);
    y = findfa(y);

    if(x != y)
        cnt++;

    if(rak[x] < rak[y])
        father[x] = y;
    else{
        father[y] = x;
        if(rak[x] == rak[y])
            rak[x]++;
    }
}

int Kruskal(int n)
{
    sort(edge, edge + tol, cmp);
    int ans = 0;

    for(int i = 0; i < tol; i++){
        int rot1 = findfa(edge[i].u);
        int rot2 = findfa(edge[i].v);
        if(rot1 != rot2){
            ans += edge[i].w;
            unite(rot1, rot2);
        }
        if(cnt == n - 1)
            break;
    }
    if(cnt < n - 1) return -1;
    else return ans;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        int n, m, k;
        scanf("%d%d%d", &n, &m, &k);
        tol = 0;

        for(int i = 0; i < m; i++){
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            addedge(u, v, w);
        }

        init(n);
        cnt = 0;
        for(int i = 0; i < k; i++){
            int t, l;
            scanf("%d%d", &t, &l);

            for(int j = 1; j < t; j++){
                int z;
                scanf("%d", &z);
                unite(l, z);
            }
        }

        sort(edge, edge + m, cmp);

        printf("%d\n", Kruskal(n));
    }

    return 0;
}
*/
/*
1
6 4 3
1 4 2
2 6 1
2 3 5
3 4 33
2 1 2
2 1 3
3 4 5 6
*/


四.Legal or Not(HDU3342)

判断是否为DAG, 有dfs和拓扑排序两种写法,我查了个拓扑排序的代码学了一下. 

#include <bits/stdc++.h>
using namespace std;
#define N 105

bool G[N][N];
int top[N];///入度

bool topsort(int n)
{
    int cnt = 0;

    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
    {
        if(!top[j]){
            top[j]--;

            cnt++;

            if(cnt == n)
                return true;

            for(int k = 0; k < n; k++){
                if(G[j][k])
                    top[k]--;
            }
        }
    }

    return false;
}

int main()
{
    int n, m;

    while(scanf("%d%d", &n, &m) != EOF && n)
    {
        memset(G, 0, sizeof G);
        memset(top, 0, sizeof top);

        for(int i = 1; i <= m; i++){
            int x, y;
            scanf("%d%d", &x, &y);
            if(!G[x][y]){///防止重复输入导致入度有问题
                G[x][y] = true;
                top[y]++;
            }
        }

        printf(topsort(n)?"YES\n":"NO\n");
    }

    return 0;
}

五.畅通工程续(HDU1874)

最短路问题, 我用Dijkstra写的,套的书上的板子.学习了用vector数组建立图的写法.

注意这是无向图,两个方向都要存.


这个哥们写了四种写法:点击打开链接

里面有SPFA,我没学过,就想着写完了后网上搜博客,更新下我的关于最短路的博客.


#include <bits/stdc++.h>
using namespace std;
#define INF 10000000
#define N 205
#define M 1005

struct edge{int to, cost;};
typedef pair<int, int> P;

vector<edge> G[M];
int d[M];

void dijkstra(int s)
{
    priority_queue<P, vector<P>, greater<P> > que;

    fill(d, d + N, INF);
    d[s] = 0;
    que.push(P(0, s));

    while(!que.empty())
    {
        P p = que.top();que.pop();

        int v = p.second;

        if(d[v] < p.first)
            continue;

        for(int i = 0; i < G[v].size(); i++){
            edge e = G[v][i];

            if(d[e.to] > d[v] + e.cost){
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to], e.to));
            }
        }
    }
}

int main()
{
    int n, m;

    while(scanf("%d%d", &n, &m) != EOF)
    {
        for(int i = 0; i < N; i++)
            G[i].clear();

        for(int i = 0; i < m; i++){
            edge temp;
            int u;
            scanf("%d%d%d", &u, &temp.to, &temp.cost);{
                G[u].push_back(temp);
                int uto = temp.to;
                temp.to = u;
                u = uto;
                G[u].push_back(temp);
            }

        }
        int s, e;
        scanf("%d%d", &s, &e);

        dijkstra(s);

        if(d[e] == INF)
            printf("-1\n");
        else
            printf("%d\n", d[e]);
    }

    return 0;
}

六.Eddy's picture(HDU1161)

最小生成树,因为是稠密图所以用Prim写的.(现在百度了一下,都是Prim)

还是用的牛客网的板子.建图是我自己建的.

#include <bits/stdc++.h>
using namespace std;
typedef pair<double, double> P;
#define MAXN 105
#define INF 10000000
bool vis[MAXN];
double lowc[MAXN];
int n;
P pots[MAXN];
double maps[MAXN][MAXN];

double prim()
{
    double ans = 0;
    memset(vis, false, sizeof vis);
    vis[1] = true;

    for(int i = 1; i <= n; i++)
        lowc[i] = maps[1][i];

    for(int i = 2; i <= n; i++){
        double minc = INF;
        int p = -1;
        for(int j = 1; j <= n; j++)
            if(!vis[j] && minc > lowc[j])
        {
            minc = lowc[j];
            p = j;
        }

        if(minc >= INF)
            return -1;

        ans += minc;

        vis[p] = true;

        for(int j = 1; j <= n; j++){
            if(!vis[j] && lowc[j] > maps[p][j])
                lowc[j] = maps[p][j];
        }
    }

    return ans;
}

int main()
{
    while(scanf("%d", &n) != EOF)
    {
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                maps[i][j] = INF;

        for(int i = 1; i <= n; i++){
            double x, y;

            scanf("%lf%lf", &x, &y);
            pots[i].first = x;
            pots[i].second = y;

            for(int j = 1; j < i; j++){
                double dx = fabs(x - pots[j].first);
                double dy = fabs(y - pots[j].second);
                maps[i][j] = maps[j][i] = sqrt(dx*dx + dy*dy);
            }
        }

        printf("%.2lf\n", prim());
    }

    return 0;
}

七.Frogger(POJ2253)

这道题想求最短路中的最长一条路.

链接:点击打开链接

讲解什么的看人家的吧.
我就是这种有点变动就写不下去的菜鸡...
忽略注释掉的Prim........太蠢了 
#include <bits/stdc++.h>
using namespace std;
#define N 202
double d[N][N];
typedef pair<int, int> P;
P p[N];

double dis(int i, int j)
{
    double x = fabs(p[i].first - p[j].first);
    double y = fabs(p[i].second - p[j].second);
    return sqrt(x * x + y * y);
}

int main()
{
    int n, Case = 0;

    while(scanf("%d", &n) != EOF && n)
    {
        for(int i = 1; i <= n; i++)
            scanf("%d%d", &p[i].first, &p[i].second);

        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= i; j++)
            d[i][j] = d[j][i] = j == i?0:dis(i, j);

        for(int k = 1; k <= n; k++)
            for(int i = 1; i <= n; i++)
                for(int j = 1; j <= n; j++)
                d[i][j] = min(d[i][j], max(d[i][k], d[k][j]));

        printf("Scenario #%d\n", ++Case);
        printf("Frog Distance = %.3lf\n\n", d[1][2]);
    }

    return 0;
}

/*
#include <bits/stdc++.h>
using namespace std;
#define INF 100000000
#define N 202
typedef pair<int, int> P;

bool vis[N];
double lowc[N];
double maps[N][N];
P pots[N];
int n;

double prim()
{
    double ans = 0;

    fill(lowc, lowc + N, INF);
    memset(vis, 0, sizeof vis);

    vis[1] = true;
    for(int i = 1; i <= n; i++)
        lowc[i] = maps[1][i];

    for(int i = 2; i <= n; i++){
        int p = -1;
        double minc = INF;

        for(int j = 1; j <= n; j++){
            if(!vis[j] && minc > lowc[j]){
                p = j;
                minc = lowc[j];
            }
        }

        if(p == -1)
            return -1;

        ans = max(ans, minc);
        vis[p] = true;

        for(int j = 1; j <= n; j++){
            if(!vis[j] && lowc[j] > maps[p][j])
                lowc[j] = maps[p][j];
        }
    }

    return ans;
}

int main()
{
    int Case = 0;

    while(scanf("%d", &n) != EOF && n)
    {
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                maps[i][j] = i != j ?INF:0;

        for(int i = 1; i <= n; i++){
            scanf("%d%d", &pots[i].first, &pots[i].second);

            for(int j = 1; j < i; j++){
                double x = abs(pots[i].first - pots[j].first);
                double y = abs(pots[i].second - pots[j].second);
                maps[i][j] = maps[j][i] = sqrt(x*x+y*y);
            }
        }

        printf("Scenario #%d\n", ++Case);
        printf("Frog Distance = %.3lf\n\n", prim());
    }

    return 0;
}
*/


八.产生冠军(HDU2094)

这题是我自己做的(欧耶!), 拓扑排序的题目.
算法很简单,根本不用拓扑排序,直接看入度为0的点是不是只有一个就好了. 

#include <bits/stdc++.h>
using namespace std;
#define N 1005

bool G[N][N];
int indeg[N];
int n, k;
string names[N];
/*
bool topsort()
{
    int cnt = 0;

    for(int i = 1; i <= k; i++)
        for(int j = 1; j <= k; j++)
    {
        if(!indeg[j]){
            indeg[j]--;

            {cnt++;cout << i << ' ' << j << ' ' << indeg[j] << endl;}

            if(cnt == k)
                return true;

            for(int l = 1; l <= k; l++){
                if(G[j][l])
                    indeg[l]--;
            }
        }
    }

    return false;
}
*/
int main()
{
    while(scanf("%d", &n) && n)
    {
        memset(G, 0, sizeof G);
        memset(indeg, 0, sizeof indeg);
        for(int j = 1; j <= 2 * n; j++)
            names[j] = "";

        k = 1;
        for(int i = 1; i <= n; i++){
            string a, b;
            cin >> a >> b;
            bool f1 = true, f2 = true;
            int pa, pb;

            for(int j = 1; j < k; j++){
                if(names[j] == a){
                    pa = j;f1 = false;
                }
                if(names[j] == b){
                    pb = j;f2 = false;
                }
            }
            if(f1){
                names[k] = a;
                pa = k;
                k++;
            }
            if(f2){
                names[k] = b;
                pb = k;
                k++;
            }

            if(!G[pa][pb]){
                G[pa][pb] = true;
                indeg[pb]++;
            }
        }

        int cnt = 0;
        for(int i = 1; i < k; i++)
            if(!indeg[i])
                cnt++;

        printf(cnt == 1?"Yes\n":"No\n");
    }

    return 0;
}


九.Ubiquitous Religions(POJ2524)

并查集.每组合一个宗教数量就减一.

#include <bits/stdc++.h>
using namespace std;
#define N 50000

int F[N];
int cnt;

void intl(int n)
{
    for(int i = 1; i <= n; i++)
        F[i] = i;
    cnt = n;
}

int find(int a)
{
    if(F[a] == a)
        return a;
    else
        return F[a] = find(F[a]);
}

void unite(int a, int b)
{
    int x = find(a);
    int y = find(b);

    if(x == y)
        return;
    else{
        F[y] = x;
        cnt--;
    }
}

int main()
{
    int Case = 0;
    int n, m;

    while(scanf("%d%d", &n, &m) != EOF && n)
    {
        intl(n);
        for(int k = 1; k <= m; k++){
            int i, j;
            scanf("%d%d", &i, &j);

            //printf("%d\n", find(8));
            unite(i, j);
        }

        printf("Case %d: %d\n", ++Case, cnt);
    }

    return 0;
}

十.最短路

题目真是取了个赤裸裸的名字.直接套Dijkstra板子就好了

#include <bits/stdc++.h>
using namespace std;
#define INF 100000000
#define N 102
#define M 1002
typedef pair<int, int> P;
struct edge{
    int to, cost;
};
vector<edge> G[N];
int d[M];
int n, m;
int ans = 0;

void dijkstra()
{
    priority_queue<P, vector<P>, greater<P> > que;

    fill(d, d + N, INF);
    d[1] = 0;
    que.push(P(0, 1));

    while(!que.empty())
    {
        P p = que.top();que.pop();

        int v = p.second;

        if(d[v] < p.first)
            continue;

        for(int i = 0; i < G[v].size(); i++){
            edge e = G[v][i];

            if(d[e.to] > d[v] + e.cost){
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to], e.to));
            }
        }
    }
}

int main()
{
    while(scanf("%d%d", &n, &m) != EOF && n)
    {
        for(int i = 1; i <= n; i++)
            G[i].clear();

        for(int i = 1; i <= m; i++){
            edge e;
            int u;
            scanf("%d%d%d", &u, &e.to, &e.cost);
            G[u].push_back(e);
            int temp = u;
            u = e.to;
            e.to = temp;
            G[u].push_back(e);
        }

        dijkstra();

        printf("%d\n", d[n]);
    }

    return 0;
}

叶子心情你不懂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图论中树的基本概念总结
yyywww666的专栏
12-22 1万+
给出树，支撑树的概念
2020暑期专题1-图论1题解1
08-08
题目【2020暑期专题1-图论1题解1】涉及到如何判断一个有向图是否是强连通的。 **强连通图**是指在一个有向图中，任意两个节点都互相可达的图。换句话说，如果存在一条从节点A到节点B的路径，同时也存在一条从节点B...
图论（二）树
热门推荐
saltriver的专栏
01-14 2万+
建立了图（graph）的认识，“树”就好理解了。“树”是一种很特别的图（graph）。用图来定义“树”：任意2点之间都连通，并且没有“环”的图。下面的图就是一颗树，因此，树是图的特例。
图论（6）树的概念，中心与形心
向上吧贺凯
04-08 7028
（一）、树的概念与应用 1.树的概念 不含圈的图称为无圈图，树是连通的无圈图。树的度为1的顶点称为树叶。 定义：称无圈图G为森林。 即无圈图G就是森林，森林可以是不连通的，若森林连通，则该森林为树。即森林可以包含很多树，每个树都是该森林的连通分量。 注意：树与森林都是简单图； 两个顶点及以上的树与森林都是偶图； ...
一张图带你看完图论第二章（包含定义、定理、公式、推导证明和例题）
mingrisanyang的博客
05-23 2207
包含第二章全部考点~没提到就是不考~ 树的定义 连通的无圈图 无圈图称为森林 树与森林都是简单图（非简单一定有圈-自环、重边） 都是偶图（无奇圈） 森林（n,m）里有K颗树，则m=n-k 森林里k对奇点--k条边不重的路，G的边集是这些路的并 归纳法证明 树的描述 树叶：度数=1分支点：度数>1 非平凡树至少有两片叶子 中心 点v离心率e(v) 从v出发最...
图论学习-2 树 （思维导图）树的定义 性质 生成树 最小生成树算法 根树 最优二元树
或左的博客
08-21 6157
树 树的概念 森林是无圈图 树是连通的无圈图 树和森林都是简单图，也都是二部图 树的一度点是树叶 树的性质 树的基本性质 定理1：G中任意两顶点间有且仅有一条路相连 证明：假设有两条路，则两条路的一部分必能构成圈 m=n-1 推论1：由k棵树组成的森林满足m=n-k 证明：数学归纳法，任意去一条边，则得到两个连通分支，分别得证 连通且无圈 在G中任意不相邻的两顶点间增加一条边，就得到唯一的一个圈 证明：由定理1，已经存在一条路，然后加一个边，则得到一个圈，并且是唯一的圈
2021_GDUT_新生专题训练_图论
Runewrz的博客
03-17 372
题解 A - Cow Contest 传送门 题意 有nnn头牛，知道mmm对强弱关系，用一对数(a,b)(a,b)(a,b)表示，意思是aaa能战胜bbb。强弱关系可以传递，如(a,b)(a,b)(a,b)且(b,c)(b,c)(b,c)则(a,c)(a,c)(a,c)。求能确定排名的牛数量。 1≤n≤100,1≤m≤45001\leq n \leq 100,1 \leq m \leq 45001≤n≤100,1≤m≤4500 思路 对于一头牛，能确定其排名相当于，比其弱加比起强的牛数量等于n−1n-1n
图论（内含matlab代码），哈密尔顿回路：TSP模拟退火、三边交换简单算法
06-08
图论是离散数学的一个重要分支，主要研究点与点之间连接关系的结构，这些连接通常用线或边来表示。在本资料中，我们关注的是哈密尔顿回路问题，这是一种典型的图论问题。哈密尔顿回路是指在一个无向图中，能够从一个...
C++图论专题(form Alex_Wei
08-07
【C++图论专题】是针对C++编程者的一个图论知识的学习专题，涵盖了图论中的核心概念和算法。这个专题适合对C++有一定基础，理解了基础数据结构（如栈、二叉树、队列）的初学者，特别是那些需要在实际编程中灵活运用...
电子科技大学2018级 研究生图论课程四次测试题（期末相关）之三——图论作业3
05-13
本资料为2019级电子科大图论及应用平时测试答案 姓名 学号 另 女 由于在考试中获得好成绩,名学牛将获得下列书籍的奖励,分别是:代数学、微积分 、微分方程、几何学、数学史、规划学、拓扑学。每门科目只有本书,而 每...
BFS，DFS，以及图（Graph），树（Tree）的思考（2）
PigeonEssence的博客
11-02 1万+
树（Tree） 由一个或多个（n>=0）节点组成的有限集合T，有且仅有一个节点称为根（root），当n>1时，其余的节点为m（m>=0）个互不相交的有限集合T1，T2，...，Tm。每个集合本身又是棵树，称其为根的子树。注意：空树也是树，树具有递归性（树中有树）。 在图论中，树的形态和计算机中树的形态是不同的，是通过根节点向上分支，更像是一个“树”而不是“树根”，从根（root）开始开枝（branch）散叶（leaf）： 之前...
牛顿广义二项式定理-母函数
叶子心情你不懂
03-28 5677
  好久没写博客了，有好多都是写成了草稿没写完。列个清单慢慢补。。 数论专题。 概率\期望专题 划分树专题 省赛训练补题 机器学习的记录 课程要求写的一些东西 cf的题 好了进入正题 广义组合数   数据结构老师让搜 (70.5)\binom{7}{0.5}(0.57​) 这种东西。搜出来是广义组合数，对应的有广义二项式定理。一看这个玩意儿ACM经常用就学一下。...
省赛训练4
叶子心情你不懂
05-12 1994
队友都不在，一个人打比赛真的累， 打不动打不动。。。。 还好这次的题目特别水。还能做几题。 Recursively Palindromic Partitions Time Limit: 1000 ms /Memory Limit: 32768 kb Description A partition of a positive integer N is a seq
概率期望讲解
叶子心情你不懂
07-18 1447
一、概率基本知识 条件概率:B发生的情况下A发生的概率 P(A∣B)=P(AB)P(B)P(A|B)=\frac{P(AB)}{P(B)}P(A∣B)=P(B)P(AB)​ 划分样本的概率 P(A)=∑i=1nP(A∣Bi)P(A)=\sum_{i=1}^{n}{P(A|B_i)}P(A)=i=1∑n​P(A∣Bi​) 贝叶斯公式 P(Bi∣A)=P(Bi)P(A∣Bi)P...
北大2018acm暑期课二动态规划
叶子心情你不懂
07-28 928
每次写动态规划都是百度百度再百度，Orz。   股票买卖 描述 最近越来越多的人都投身股市，阿福也有点心动了。谨记着“股市有风险，入市需谨慎”，阿福决定先来研究一下简化版的股票买卖问题。 假设阿福已经准确预测出了某只股票在未来 N 天的价格，他希望买卖两次，使得获得的利润最高。为了计算简单起见，利润的计算方式为卖出的价格减去买入的价格。 同一天可以进行多次买卖。但是在第一次买入之后，必...
北大2018acm暑期课一贪心&二分&分治
叶子心情你不懂
07-25 842
01-派 总时间限制: 1000ms 内存限制: 65536kB 描述 我的生日要到了！根据习俗，我需要将一些派分给大家。我有N个不同口味、不同大小的派。有F个朋友会来参加我的派对，每个人会拿到一块派（必须一个派的一块，不能由几个派的小块拼成；可以是一整个派）。 我的朋友们都特别小气，如果有人拿到更大的一块，就会开始抱怨。因此所有人拿到的派是同样大小的（但不需要是同样形状的），虽然这样有些...
生成树计数——基尔霍夫矩阵树定理证明
叶子心情你不懂
08-17 793
关于比内柯西公式的证明还是有点晕，数学不好是硬伤。    
"2020暑期专题：图论解题报告，HDU1269题分析及解法详解
2020暑期专题1中的图论一题解1主要是关于HDU1269题的解答。这道题的题意是给定n个点和m条有向边，要求判断是否每个点都可以相互到达。解题思路是利用Tarjan算法来求解强连通分量（SCC），然后判断SCC的数量是否为1。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值