ACM 模板

就让这篇文章以后就用来保存一些犀利的算法模板吧~~~~~~上吧 ！ 皮卡丘~~~~~就决定是你了~~~~~~~~~~~~~~~~

用Bellman - Ford 算法判断一个图里面是否存在负环（PS ： 先收了，以后有了更好的算法再来update）

bool BF(int M)
{
      int cnt =  1;
      while (true)
      {
            int flag  = 0;
            for (int i=1;i<M;i++)
                  if (dist[edge[i].e] > dist[edge[i].s] + edge[i].d)
                  {
                        flag = 1;
                        dist[edge[i].e] = dist[edge[i].s] + edge[i].d;
                  }
            if (flag == 0)return 0; //无法再进行松弛操作，所以返回没有负环 
            if (cnt ++ > M - 1)return 1;  //多余循环说明存在负环
      }
}

今天用邻接表写了一个 Dijkstra 第一次~~~~~~

暂时就用那段搓码做模板吧~~~

void init()
{
    memset(first,-1,sizeof(first));
    Q = 0;
}

void Read(int a,int b,int c)//a - > b 权值是 c
{
    u[Q] = a; v[Q] = b; w[Q] = c;
    next[Q] = first[u[Q]];
    first[u[Q]] = Q ++;
}

int Dijkstra(int sx,int ex)
{
    memset(vis,0,sizeof(vis));
    for (int i=1;i<=N;i++)
        dist[i] = INF;
    dist[sx] = 0;
    for (int i=1;i<=N;i++)
    {
        int x,m = INF;
        for (int  y=1;y<=N;y++)
            if (vis[y] == 0 && first[y] != -1 && dist[y] < m)
            {
                x = y;
                m = dist[y];
            }
        vis[x] = 1;
        if (x == ex)break;
        for (int y=first[x];y!=-1;y=next[y])
            dist[v[y]] = MIN(dist[x]+w[y],dist[v[y]]);
    }
    return dist[ex];
}

开始刷线段树了，先贴一个HH大牛的代码作为模板 ：

int sum[maxn * 4];

//    将两个子节点的信息保存到父节点上去~~
void PushUP(int e)
{
      sum[e] = sum[e * 2] + sum[e * 2 + 1];
}

//    建立一棵线段树
void build(int l,int r,int e)
{
      if (l == r)
      {
            scanf("%d",&sum[e]);
            return ;
      }
      int mid = (l + r) / 2;
      build(l , mid , e * 2);
      build(mid + 1 , r , e * 2 + 1);
      PushUP(e);
}

//    进行更新操作~~
void update(int p,int add,int l,int r,int e)
{
      if (l == r)
	{
            sum[e] += add;
            return ;
      }
      int mid = (l + r) / 2;
      if (p <= mid) update(p , add , l , mid , e * 2);
      else update(p , add , mid + 1 , r , e * 2 + 1);
      PushUP(e);
}

//    询问操作~~
int query(int L,int R,int l,int r,int e)
{
      if (L <= l && r <= R)
      {
            return sum[e];
      }
      int mid = (l + r) / 2;
      int ans = 0;
      if (L <= mid) ans += query(L , R , l , mid , e * 2);
      if (R > mid) ans += query(L , R , mid + 1, r , e * 2 + 1);
      return ans;
}

默默的再贴一个刘汝佳的那本书上的一个Edmonds - Karp 算法模板（略改）

int cap[maxn][maxn];  //      边的容量
int flow[maxn][maxn]; //      边的流量
int a[maxn * 100];    //      最小残量
int p[maxn * 100];    //      保存路径
int N,M;
int EK(int s,int t)
{
      queue<int> q;
      memset(flow,0,sizeof(flow));
      int ans = 0;
      while (true)
      {
            memset(a,0,sizeof(a));
            a[s] = INF;
            q.push(s);
            while (!q.empty())
            {
                  int u = q.front();q.pop();
                  for (int v=1;v<=N;v++)
                        if (!a[v] && cap[u][v] > flow[u][v])
                        {
                              p[v] = u; q.push(v);
                              a[v] = MIN(a[u],cap[u][v] - flow[u][v]);
                        }
            }
            if (a[t] == 0)return ans;
            for (int u=t;u!=s;u=p[u])
            {
                  flow[p[u]][u] += a[t];
                  flow[u][p[u]] -= a[t];
            }
            ans += a[t];
      }
}