C++混合笔记

#include<bits/stdc++.h>
using namespace std;
const int inf=1e9;
int Begin[100010],Next[100010],To[100010],W[100010],e;
int n,m;
int dis[510];
bool vis[510];
void add(int a,int b,int c)
{
    To[++e] = b;
    W[e] = c;
    Next[e] = Begin[a];
    Begin[a] = e;
}
int dijkstra()
{
    for(int i=1;i<=n;i++)
    {
        int pos=-1,mi=INT_MAX;
        for(int j=1;j<=n;j++)
        {
            if(dis[j]<mi&&!vis[j])
            {
                pos = j;
                mi = dis[j];
            }
        }
        vis[pos] = 1;
        for(int j=Begin[pos];j;j=Next[j])
        {
            int v=To[j];
            if(dis[pos]+W[j]<dis[v])
            {
                dis[v] = dis[pos]+W[j];
            }
        }
    }
    if(dis[n] == inf)
    {
        return -1;
    }
    return dis[n];
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        dis[i] = inf;
    }
    dis[1] = 0;
    // vis[1] = 1;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
    }
    cout<<dijkstra();
    return 0;
}

Dijkstra堆优化：(链式前向星)

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int inf=1e9;
int Begin[200010],Next[200010],To[200010],W[200010],e;
int n,m;
int dis[200010];
bool vis[200010];
priority_queue<PII,vector<PII>,greater<PII>> pq;
void add(int a,int b,int c)
{
    To[++e] = b;
    W[e] = c;
    Next[e] = Begin[a];
    Begin[a] = e;
}
int dijkstra()
{
    pq.push({0,1});
    for(int i=1;i<=n;i++)
    {
        auto a=pq.top();
        pq.pop();
        int pos=a.second;
        if(vis[pos])
        {
            continue;
        }
        vis[pos] = 1;
        for(int j=Begin[pos];j;j=Next[j])
        {
            int v=To[j];
            if(dis[pos]+W[j]<dis[v])
            {
                dis[v] = dis[pos]+W[j];
                pq.push({dis[v],v});
            }
        }
    }
    if(dis[n] == inf)
    {
        return -1;
    }
    return dis[n];
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        dis[i] = inf;
    }
    dis[1] = 0;
    // vis[1] = 1;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
    }
    cout<<dijkstra();
    return 0;
}

SPFA:

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 100010;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        int t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return dist[n];
}

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

    memset(h, -1, sizeof h);

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    int t = spfa();

    if (t == 0x3f3f3f3f) puts("impossible");
    else printf("%d\n", t);

    return 0;
}

Bellman_ford

#include<bits/stdc++.h>
using namespace std;
struct edge{
    int a,b,w;
}ed[10010];
int n,m,k;
int dis[10010],backup[10010];
int bellman_ford()
{
    for(int i=1;i<=k;i++)
    {
        memcpy(backup,dis,sizeof(dis));
        for(int j=1;j<=m;j++)
        {
            int a=ed[j].a,b=ed[j].b,w=ed[j].w;
            dis[b] = min(dis[b],backup[a]+w);
        }
    }
    if(dis[n]>0x3f3f3f3f/2)
    {
        cout<<"impossible";
        exit(0);
    }
    return dis[n];
}
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++)
    {
        cin>>ed[i].a>>ed[i].b>>ed[i].w;
    }
    memset(dis,0x3f,sizeof(dis));
    dis[1]=0;
    int t=bellman_ford();
    cout<<t;
    return 0;
}

1：Trie

int son[100010][26],cnt[100010],idx;
char s[100010];
void insert(char s[])
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int u=s[i]-'a';
        if(!son[p][u])
        {
            son[p][u] = ++idx;
        }
        p = son[p][u];
    }
    cnt[p]++;
}
int find1(char s[])
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int u=s[i]-'a';
        if(!son[p][u])
        {
            return 0;
        }
        p = son[p][u];
    }
    return cnt[p];
}

2.并查集

int fa[100010];
int find(int x)
{
    if(fa[x]!=x)
    {
        return fa[x] = find(fa[x]);
    }
}
int insert(int a,int b)
{
    fa[find(a)] = find(b);
}

组合数原公式：

组合数公式：

$C_{a}^{b} = C_{a-1}^{b}+C_{a-1}^{b-1}$

在： $1 \le b\le a\le 2000$ 可用递推

代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 2010, mod = 1e9 + 7;
int c[N][N];
void init()
{
    for (int i = 0; i < N; i ++ )
        for (int j = 0; j <= i; j ++ )
            if (!j) c[i][j] = 1;
            else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
int main()
{
    int n;
    init();
    scanf("%d", &n);
    while (n -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);

        printf("%d\n", c[a][b]);
    }
    return 0;
}

逆元预处理来求：

在 $1\le b\le a\le 10^5$ 可用

先定义两个东东：

更新后的组合公式：

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 100010, mod = 1e9 + 7;
int fact[N], infact[N];
int qmi(int a, int k, int p)
{
    int res = 1;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}
int main()
{
    fact[0] = infact[0] = 1;
    for (int i = 1; i < N; i ++ )
    {
        fact[i] = (LL)fact[i - 1] * i % mod;
        infact[i] = (LL)infact[i - 1] * qmi(i, mod - 2, mod) % mod;
    }
    int n;
    scanf("%d", &n);
    while (n -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("%d\n", (LL)fact[a] * infact[b] % mod * infact[a - b] % mod);
    }
    return 0;
}

组合数卢卡斯定理：
$C_a^b \equiv C_{a \bmod p}^{b \bmod p} \cdot C_{a/p}^{b/p} (\bmod p)$

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int qmi(int a, int k, int p)
{
    int res = 1;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}
int C(int a, int b, int p)
{
    if (b > a) return 0;
    int res = 1;
    for (int i = 1, j = a; i <= b; i ++, j -- )
    {
        res = (LL)res * j % p;
        res = (LL)res * qmi(i, p - 2, p) % p;
    }
    return res;
}
int lucas(LL a, LL b, int p)
{
    if (a < p && b < p) return C(a, b, p);
    return (LL)C(a % p, b % p, p) * lucas(a / p, b / p, p) % p;
}
int main()
{
    int n;
    cin >> n;
    while (n -- )
    {
        LL a, b;
        int p;
        cin >> a >> b >> p;
        cout << lucas(a, b, p) << endl;
    }
    return 0;
}

卡特兰数：

$CAT(n) = C_{2n}^n/(n+1)$

01背包转移方程：

$f_{i,j} = max(f_{i,j-1},f_{i,j-v_i}+w_i)$

01背包注意事项：

循环是0~m。
下标要注意。
每次循环开始时，f[i][j] = f[i][j-1]。
f[i][j] = f[i][j-1]后要加判断：if(j>=v[i])否则会访问负下标。
结合代码会好看一些。

01背包代码：

#include<bits/stdc++.h>
using namespace std;
int a[1010];
int v[1010],w[1010];
int f[1010][1010];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            f[i][j] = f[i-1][j];
            if(j<v[i])
            {
                continue;
            }
            f[i][j] = max(f[i][j],f[i-1][j-v[i]]+w[i]);
        }
    }
    cout<<f[n][m];
    return 0;
}

01背包空间优化版（滚动数组）：

#include<bits/stdc++.h>
using namespace std;
int a[1010];
int v[1010],w[1010];
int f[1010];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=v[i];j--)
        {
            f[j] = max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m];
    return 0;
}

时间复杂度： $O(nm)$

完全背包转移方程：

$f_{i,j} = max(f[i][j],f[i-1][j-v_i]*k]+w[i]*k)$

完全背包变量意思：

i:下标

j:容量

k:每个物品个数

完全背包朴素版：

#include<bits/stdc++.h>
using namespace std;
int a[1010];
int v[1010],w[1010];
int f[1010][1010];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            for(int k=0;k*v[i]<=j;k++)
            {
                f[i][j] = max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
            }
        }
    }
    cout<<f[n][m];
    return 0;
}

复杂度： $O(nm^2)$

完全背包时间优化版：

#include<bits/stdc++.h>
using namespace std;
int a[1010];
int v[1010],w[1010];
int f[1010][1010];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            f[i][j] = f[i-1][j];
            if(j>=v[i]) f[i][j] = max(f[i][j],f[i][j-v[i]]+w[i]);
        }
    }
    cout<<f[n][m];
    return 0;
}

复杂度： $O(nm)$

完全背包时间+空间优化版（滚动数组）：

#include<bits/stdc++.h>
using namespace std;
int a[1010];
int v[1010],w[1010];
int f[1010];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=v[i];j<=m;j++)
        {
            f[j] = max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m];
    return 0;
}

复杂度： $O(nm)$

多重背包转移方程：

$f_{i,j} = max(f_{i,j},f_{i-1,j-v_i*k}+w_i*k)$

多重背包朴素写法（暴力）：

#include<bits/stdc++.h>
using namespace std;
int a[1010];
int v[1010],w[1010];
int f[1010][1010];
int s[1010];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i]>>s[i];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            for(int k=0;k*v[i]<=j&&k<=s[i];k++)
            {
                f[i][j] = max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
            }
        }
    }
    cout<<f[n][m];
    return 0;
}

复杂度： $O(nms)$

多重背包时间+空间优化版：（二进制分组优化）

#include<bits/stdc++.h>
using namespace std;
int f[25000];
int v[25000];
int w[25000];
int cnt;
void change(int a,int b,int s)
{
    int k=1;
    while(k<=s)
    {
        cnt++;
        v[cnt] = a*k;
        w[cnt] = b*k;
        s-=k;
        k*=2;
    }
    if(s)
    {
        cnt++;
        v[cnt] = a*s;
        w[cnt] = b*s;
    }
}
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int a,b,s;
        cin>>a>>b>>s;
        change(a,b,s);
    }
    for(int i=1;i<=cnt;i++)
    {
        for(int j=m;j>=v[i];j--)
        {
            f[j] = max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m];
    return 0;
}

复杂度： $O(nmlog_2 s)$

多重背包超级优化（单调队列）：

#include<bits/stdc++.h>
using namespace std;
int dp[20010],pre[20010],q[20010];
int n,m;
int main()
{
	cin>>n>>m;
	for(int i=0;i<n;i++)
	{
		memcpy(pre,dp,sizeof(dp));
		int v,w,s;
		cin>>v>>w>>s;
		for(int j=0;j<v;j++)
		{
			int head=0,tail=-1;
			for(int k=j;k<=m;k+=v)
			{
				if(head<=tail&&k-s*v>q[head])
				{
					++head;
				}
				while(head<=tail&&pre[q[tail]]-(q[tail]-j)/v*w<=pre[k]-(k-j)/v*w)
				{
					--tail;
				}
				if(head<=tail)
				{
					dp[k] = max(dp[k],pre[q[head]]+(k-q[head])/v*w);	
				}
				q[++tail] = k;
			}
		}
	}
	cout<<dp[m]<<endl;
	return 0;
}

复杂度： $O(nm)$

分组背包转移方程：

$f_{i,j} = max(f_{i-1,j},f_{i-1,j-v_{i,k}}+w_{i,k})$

分组背包空间优化版：（滚动数组）

#include<bits/stdc++.h>
using namespace std;
int v[110][110],w[110][110];
int s[110];
int f[110];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>s[i];
        for(int j=1;j<=s[i];j++)
        {
            cin>>v[i][j]>>w[i][j];
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=0;j--)
        {
            for(int k=0;k<=s[i];k++)
            {
                if(v[i][k]<=j)
                {
                    f[j] = max(f[j],f[j-v[i][k]]+w[i][k]);
                }
            }
        }
    }
    cout<<f[m];
    return 0;
}

线性DP：

经典例题1：数字三角形

题目链接

#include<bits/stdc++.h>
using namespace std;
int f[1010][1010];
int a[1010][1010];
int main()
{
    int n,m;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=i;j++)
        {
            cin>>a[i][j];
        }
    }
    memset(f,-0x3f,sizeof(f));
    f[1][1] = a[1][1];
    for(int i=2;i<=n;i++)
    {
        for(int j=1;j<=i;j++)
        {
            f[i][j] = max(f[i-1][j],f[i-1][j-1])+a[i][j];
        }
    }
    int ret=INT_MIN;
    for(int i=1;i<=n;i++)
    {
        ret=max(ret,f[n][i]);
    }
    cout<<ret;
}

最长上升子序列求序列:

题目链接

#include<bits/stdc++.h>
using namespace std;
int a[1010];
int f[1010];
int g[1010];
int main()
{
    int n;
    cin>>n;
    // cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    for(int i=1;i<=n;i++)
    {
        f[i]= 1;
        g[i]=0;
        for(int j=1;j<i;j++)
        {
            if(a[j]<a[i])
            {
                if(f[i]<f[j]+1)
                {
                    f[i] = f[j]+1;
                    g[i] = j;
                }
            }
        }
    }
    int ret=0;
    for(int i=1;i<=n;i++)
    {
        if(f[ret]<f[i])
        {
            ret = i;
        }
    }
    cout<<f[ret]<<'\n';
    for(int i=1,len=f[ret];i<=len;i++)
    {
        cout<<a[ret]<<' ';
        ret = g[ret];
    }
    return 0;
}

ltl1

关注

17
点赞
踩
24

收藏

觉得还不错? 一键收藏
1
评论
C++混合笔记

目录先上一波最短路模板：Dijkstra朴素：（链式前向星）Dijkstra堆优化：(链式前向星)SPFA:Bellman_ford 1：Trie2.并查集组合数原公式：组合数公式：编辑逆元预处理来求：在编辑可用代码：组合数卢卡斯定理：代码：卡特兰数：编辑01背包流程图：01背包集合图：01背包转移方程：01背包注意事项：01背包代码：01背包空间优化版（滚动数组）：时间复杂度：编辑完全背包流程+集合图：完全背包转移方程：完全背包变量意思：完全背包朴素版：复杂度：编辑完全背包时间优化版：
复制链接

扫一扫