图--板子

一、存图方法

1、邻接矩阵：

	int G[maxn][maxn];
	int n,m;
	memset(G,inf,sizeof(G));
	scanf("%d%d",&n,&m);	//n为点数，m为边数
	for(int i=0;i<m;i++){
		scanf("%d%d%d",&u,&v,&d);
		if(G[u][v]>d)
			G[u][v] = d;
	}

2、邻接表：

1. vector实现：

struct node{
    int id;
    int d;
};
vector<node> v[maxn];
void Init(int n)
{
    for(int i=0;i<n;i++)
        v[i].clear();
}
void add(int u,int v,int dd)
{
    node temp;
    temp.id = v;
    temp.v = dd;
    v[u].push_back(temp);
}

2. 静态链表

struct node{
    int id;
    int d;
    int Next;
}side[maxn];
int head[maxn];
int cnt;
void Init(int n)
{
    for(int i=0;i<n;i++)
        head[i] = -1;
    cnt = 0;
}
void add(int u,int v,int dd)
{
    side[cnt].id = v;
    side[cnt].d = dd;
    side[cnt].Next = head[u];
    head[u] = cnt++;
}

二、图的遍历

1、DFS遍历：

1. 邻接矩阵版

int n,G[maxn][maxn];
bool vis[maxn] = {false};

void DFS(int u,int depth)
{
    vis[u] = true;
    for(int v=0;v<n;v++){
        if(vis[v]==false&&G[u][v]!=inf){
            DFS(v,depth+1);
        }
    }
}
void DFETrave() //遍历图G
{
    for(int u=0;u<n;u++){
        if(vis[u]==false){
            DFS(u,1);
        }
    }
}

2. 邻接表版

vector<int> Adj[maxn];
int n;
bool vis[maxn] = {false};

void DFS(int u,int depth)
{
    vis[u] = true;
    for(int i=0;i<Adj[u].size();i++){
        int v = Adj[u][i];
        if(vis[v]==false){
            DFS(v,depth+1);
        }
    }
}
void DFSTrave() //遍历图G
{
    for(int u=0;u<n;u++){
        if(vis[u]==false){
            DFS(u,1);
        }
    }
}

2、BFS

1. 邻接矩阵版。

void BFS(int u)
{
    queue<int> q;
    q.push(u);
    inq[u] = true;
    while(!q.empty()){
        int u = q.front();
        q.pop();
        for(int v=0;v<n;v++){
            if(inq[v]==false&&G[u][v]!=inf){
                q.push(v);
                inq[v] = true;
            }
        }
    }
}
void BFSTrace()
{
    for(int u=0;u<n;u++){
        if(inq[u]==false){
            BFS(u);
        }
    }
}

2.邻接表版（vector）

struct Node{
    int v;
    int layer;
};
void BFS(int s)
{
    queue<Node> q;
    Node start;
    start.v = s;
    start.player = 0;
    q.push(start);
    inq[start.v] = true;
    while(!q.empty()){
        Node topNode = q.front();
        q.pop();
        int u = topNode.v;
        for(int i=0;i<Adj[u].size();i++){
            Node next = Adj[u][i];
            next.layer = topNode.layer + 1;
            if(inq[naxt.v]==false){
                q.push(next);
                inq[next.v] = true;
            }
        }
    }
}

拓扑排序

struct edge{
    int to;
    int cost;
};
vector<edge> Adj[maxn];
int n,m,di[maxn];
int k,pre[maxn];
void Init()
{
    for(int i=1;i<=n;i++)
        Adj[i].clear();
}
void add(int u,int v,int d)
{
    edge tmp;
    tmp.to = v,tmp.cost = d;
    Adj[u].push_back(tmp);
}
bool topoloqicalSort()
{
    int num = 0;
    k = 0;
    queue<int> q;
    for(int i=1;i<=n;i++){
        if(di[i]==0){
            q.push(i);
        }
    }
    while(!q.empty()){
        int u = q.front();
        pre[k++] = u;	//记路径
        q.pop();
        for(int i=0;i<Adj[u].size();i++){
            int v = Adj[u][i].to;
            di[v]--;
            if(di[v]==0)    q.push(v);
        }
        Adj[u].clear();
        num++;
    }
    if(num==n)  return true;
    else return false;
}

树的直径bfs

#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 1e5+7;
const int maxm = 1e5+7; 

struct node{
	int id;
	int d;
	int Next; 
}side[maxm]; 

int head[maxn];
int cnt = 0;

void Init()
{
	memset(head,-1,sizeof(head));
	cnt = 0;
}

void add(int x,int y,int d)
{
    side[cnt].id = y;
    side[cnt].d = d;
    side[cnt].Next = head[x];
    head[x] = cnt++;
}
struct Node{
	int id;
	int d;
};
int mk[maxn];
int bfs(int x,int &d)
{
	memset(mk,0,sizeof(mk));
	queue <Node> q;
	Node tmp;
	tmp.id = x;
	tmp.d = 0;
	q.push(tmp);
	mk[x] = 1;
	int mx = 0,ans = x;
	while(q.size())
	{
	    tmp = q.front();
		q.pop();	
		for(int i = head[tmp.id]; i!=-1; i=side[i].Next)
		{
			int y = side[i].id;
			if(mk[y]) continue;
			mk[y] = 1;
			Node nd;
			nd.id = y;
			nd.d = tmp.d+side[i].d;
			if(nd.d > mx) 
			{
				mx = nd.d;
				ans = y;
			}
			q.push(nd);	
		}
	}
	d = mx;
	return ans;
}

int main()
{
	Init();
    int x,y,w;
    while(scanf("%d%d%d",&x,&y,&w)!=EOF)
    {
    	add(x,y,w);
    	add(y,x,w);
	}
	int d;
	int u = bfs(1,d);
	int v = bfs(u,d);
	printf("%d\n",d);
    return 0;
}

树的直径dfs

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define MAX 100000
using namespace std;
struct node{
	int id;
	int d;
	int next;
}side[400000];
int head[100000];
int vis[100000];
int n,m,f,ans;
int cnt=0;
void add(int x,int y,int w)
{
	side[cnt].id=y;
	side[cnt].d=w;
	side[cnt].next=head[x];
	head[x]=cnt++;
}
void Init()
{
	memset(head,-1,sizeof(head));
	cnt=0;
}
void dfs(int x,int num)
{
	vis[x]=1;
	if(num>ans)
	{
		ans=num;
		f=x;
	}
	for(int i=head[x];i!=-1;i=side[i].next)
	{
		if(!vis[side[i].id])
		dfs(side[i].id,num+side[i].d);
	}
}
int main()
{
	Init();
	scanf("%d",&n);
	m=n-1;
	while(m--)
	{
		int x,y,w;
		scanf("%d%d",&x,&y);
		add(x,y,1);
		add(y,x,1);
	}
	ans=0;
	memset(vis,0,sizeof(vis));
	dfs(1,0);
	memset(vis,0,sizeof(vis));
	dfs(f,0);
	printf("%d\n",ans);
	return 0;
}

构图：

struct node{
	int id,w;
	int next;
}side[Maxm];
int cnt=0,head[Maxn],vis[Maxn],dis[Maxn];
void init(){
	memset(head,-1,sizeof(head));
	memset(vis,0,sizeof(vis));
	memset(dis,0x3f3f3f3f,sizeof(dis));
	cnt=0;
}
void add(int x,int y,int d){
	side[cnt].id=y;
	side[cnt].w=d;
	side[cnt].next=head[x];
	head[x]=cnt++;
}

Dijkstra

void Dijkstra(int s,int e)
{
	dis[s] = 0;
	sum[s]=sorce[s];
        for(int k = 0;k< n;k++)
	{
		int minw = 0x3f3f3f3f,minv;
		for(int i = 0;i< n;i++)//取最小权值点
		{
			if(vis[i]) continue;
			if(dis[i]< minw)
				minw = dis[i],minv = i;
		}
		
		vis[minv] = 1;//标记走过
		if(minv == e) break;//遇终点break
		for(int i = 0;i< n;i++)
		{
			if(vis[i]||!mp[minv][i]) continue;
			if(dis[i]>dis[minv]+mp[minv][i]){
				dis[i]=dis[minv]+mp[minv][i];
				sum[i]=sum[minv]+sorce[i];
			}
		}
	}

…

struct Node{
	int pos;
	int cost;
	Node(){}
	Node(int pos,int cost):pos(pos),cost(cost){}
	friend bool operator < (Node a,Node b){
		return a.cost>b.cost;
	}
};
void dist(int sx,int ex){
	priority_queue<Node>q;
	q.push(Node(sx,0));
	dis[sx]=0;
	while(!q.empty()){
		Node tmp=q.top();
		q.pop();
		if(vis[tmp.pos])continue;
		vis[tmp.pos]=1;
		if(tmp.pos==ex)break;
		for(int i=head[tmp.pos];i!=-1;i=side[i].next){
			int ans=side[i].id;
			if(dis[ans]>dis[tmp.pos]+side[i].w){
			 dis[ans]=dis[tmp.pos]+side[i].w;
			 q.push(Node(ans,dis[ans]));
		}
		}
	}