一本通01背包专栏

最新推荐文章于 2022-12-03 10:45:32 发布

Myajlk

最新推荐文章于 2022-12-03 10:45:32 发布

阅读量350

点赞数

CC 4.0 BY-SA版权

分类专栏：一本通

本文链接：https://blog.youkuaiyun.com/qq_52273733/article/details/119223246

一本通专栏收录该内容

9 篇文章

订阅专栏

本文探讨了不同类型的背包问题，包括01背包、完全背包、多重背包、混合背包和分组背包，以及如何利用动态规划求解这些问题，以实现物品价值最大化。此外，还涉及到了其他几种组合优化问题，如潜水员的气瓶选择、货币系统的组合计数、演讲大厅的安排和火车票的最经济路径等。这些问题展示了在资源有限的情况下，如何通过算法找到最佳决策策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

01背包问题

【问题描述】

一个旅行者有一个最多能装 M 公斤的背包，现在有 n件物品，它们的重量分别是W1，W2，…,Wn,它们的价值分别为C1,C2,…,Cn，求旅行者能获得最大总价值。

【输入形式】

第一行：两个整数，M(背包容量，M≤200)和N(物品数量，N≤30)；

第2…N+1行：每行二个整数Wi，Ci，表示每个物品的重量和价值。

【输出形式】

仅一行，一个数，表示最大总价值。【样例输入】

【样例输出】

10 4

2 1

3 3

4 5

7 9

【样例说明】

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int n,m,v,w;
int dp[MAX];
int main(){  
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> m >> n;
    for(int i = 1 ; i <= n ; i ++ ){
    	 int v , w;
    	 cin >> w >> v;
    	 for(int j = m ; j >= w ; j--)
    	  dp[j] = max(dp[j],dp[j-w] + v);
	}
	cout<<dp[m];
	return 0;
}

完全背包

【问题描述】

设有n种物品，每种物品有一个重量及一个价值。但每种物品的数量是无限的，同时有一个背包，最大载重量为M，今从n种物品中选取若干件(同一种物品可以多次选取)，使其重量的和小于等于M，而价值的和为最大。

【输入形式】

第一行：两个整数，M(背包容量，M≤200)和N(物品数量，N≤30)；

第2…N+1行：每行二个整数Wi,Ci，表示每个物品的重量和价值。

【输出形式】

仅一行，一个数，表示最大总价值

【样例输入】

10 4

2 1

3 3

4 5

7 9

【样例输出】

max=12

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int n,m,v,w;
int dp[MAX];
int main(){  
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> m >> n;
    for(int i = 1 ; i <= n ; i ++ ){
    	 int v , w;
    	 cin >> w >> v;
    	 for(int j = w ; j <= m ; j++)
    	  dp[j] = max(dp[j],dp[j-w] + v);
	}
	cout<<"max="<<dp[m];
	return 0;
}

庆功会

【问题描述】

庆功会为了庆贺班级在校运动会上取得全校第一名成绩，班主任决定开一场庆功会，为此拨款购买奖品犒劳运动员。期望拨款金额能购买最大价值的奖品，可以补充他们的精力和体力。

【输入形式】

第1行两个数n（n<=500）,m（m<=6000），其中n代表希望购买的奖品的种数，m表示拨款金额。接下来n行，每行3个数，v,w,s分别表示第i种奖品的价格、价值（价格与价值是不同的概念）和能购买的最大数量（买0件到s件均可），其中v<=100，w<=1000，s<=10.

【输出形式】

一个数，表示此次购买能获得的最大的价值（注意：不是价格！）

【样例输入】

5 1000

80 20 4

40 50 9

30 50 7

40 30 6

20 20 1

【样例输出】

1040


# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 
int n ,m, dp[MAX],a[MAX],len,q[MAX],p[MAX];
struct Node{
	int v,w;
};
vector<Node>goods;
int main(){  
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m;
     for(int i = 0 ; i < n ; i ++ ){
	    int v,w,s;
	    cin >> v >> w >> s;
	    for(int k = 1 ; k <= s ; k*=2){
		 s -= k;
		 goods.push_back({v * k , w * k});
	     }
	  if(s > 0) goods.push_back({s * v , s * w});
   }
    for(int i = 0 ; i < goods.size() ; i ++ )
     for(int j = m ; j >= goods[i].v ; j--)
      dp[j] = max(dp[j],dp[j-goods[i].v  ]+goods[i].w);
    cout<<dp[m]; 
	return 0;
}

混合背包

【问题描述】

一个旅行者有一个最多能装V公斤的背包，那么原则上有n件物品，他们的重量分别是W1，W2，…，Wn，它们的价值分别为C1，C2，…，Cn。有的物品只可以取一次（01背包），有的物品可以取无限次（完全背包），有的物品可以取的次数有一个上限（多重背包）。求解将哪些物品装入背包可以使这些物品的费用总和不超过背包容量，且价值总和最大。

【输入形式】

第1行：两个整数，M（背包容量，M<=200）,N（物品数量，N<=30）；

第2行至n+1行：每行三个整数Wi，Ci，Pi，前两个整数分别表示每个物品的重量，价值，第三个整数若为0，则说明此物品可以购买无数件；若为其他数字，则为此物品可购买的最多件数（Pi）。

【输出形式】

仅一行，一个数，表示最大总价值。

【样例输入】

10 3

2 1 0

3 3 1

4 5 4

【样例输出】

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int n,m,v,w;
int dp[MAX];
int main(){  
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> m >> n;
    for(int i = 1 ; i <= n ; i ++ ){
    	 int v , w,s;
    	 cin >> w >> v >> s;
    	 if(s == 0){
    	 	 for(int j = w ; j <= m ; j++)
    	      dp[j] = max(dp[j],dp[j-w] + v);
		   }
		else{
		   for(int j = m ; j >= w ; j-- )
            for(int k = 0 ;k <= s && k * w <= j ;k++)
    	      dp[j] = max(dp[j],dp[j - w*k] + v * k);
		}
    	
	}
	cout<<dp[m];
	return 0;
}

潜水员

【问题描述】

潜水员为了潜水要使用特殊的装备。他有一个带2种气体的气缸：一个为氧气，一个为氮气。让潜水员下潜的深度需要各种的数量的氧和氮。潜水员有一定数量的气缸。每个气缸都有重量和气体容量。潜水员为了完成他的工作需要特定数量的氧和氮。他完成工作所需气缸的总重的最低限度的是多少？

例如：潜水员有5个气缸。每行三个数字为：氧，氮的（升）量和气缸的重量：

3 36 120
10 25 129
5 50 250
1 45 130
4 20 119

如果潜水员需要5升的氧和60升的氮则总重最小为249（1，2或者4，5号气缸）。

你的任务就是计算潜水员为了完成他的工作需要的气缸的重量的最低值。
【输入形式】

第一行有2整数m，n（1<=m<=21，1<=n<=79）。它们表示氧，氮各自需要的量。

第二行为整数k（1<=k<=1000）表示气缸的个数。

此后的k行，每行包括ai，bi，ci（1<=ai<=21，1<=bi<=79，1<=ci<=800）3个整数。这些各自是：第i个气缸里的氧和氮的容量及汽缸重量。
【输出形式】

仅一行包含一个整数，为潜水员完成工作所需的气缸的重量总和的最低值。
【样例输入】

5 60

3 36 120

10 25 129

5 50 250

1 45 130

4 20 119

【样例输出】

249

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int m,n;
int y,d,w;
int k;
int dp[105][105];

int main(){  
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> m >> n;
    cin >> k;
    memset(dp,0x3f,sizeof dp);
    dp[0][0] = 0;
  for (int i = 0; i < k ; i++) {
  	    cin >> y >> d >> w;
    	for (int j = m; j >= 0; j--) {
            for (int k = n; k >= 0; k--) {
            	int t1 = min(m, j + y), t2 = min(n, k + d);
                dp[t1][t2] = min(dp[t1][t2], dp[j][k] + w);
            }
        }
    }

	cout<<dp[m][n];
	return 0;
}

分组背包

【问题描述】

一个旅行者有一个最多能装V公斤的背包，现在有n件物品，它们的重量分别是W1，W2，…Wn，它们的价值分别为C1，C2…，Cn。这些物品被划分为若干组，每组中的物品互相冲突，最多选一件。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

【输入形式】

第1行：三个整数，V（背包容量，V<=200）,N（物品数量，N<=30）和T（最大组号，T<=10）；

第2行至N+1行：每行三个整数Wi，Ci，P，表示每个物品的重量、价值、所属组号。

【输出形式】

仅一行，一个数，表示最大总价值。

【样例输入】

10 6 3

2 1 1

3 3 1

4 8 2

6 9 2

2 8 3

3 9 3

【样例输出】

//#pragma GCC optimize(1)
//#pragma GCC optimize(2)
//#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int m,n,t;
int a[105][20];
int num[105];
int dp[MAX];
int v[MAX],w[MAX];
vector<int>bag[MAX];

int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> m >> n >> t;;
    for(int i = 1 ; i <= n ; i ++ ){
    	int x;
    	cin >> w[i] >> v[i] >> x;
        bag[x].push_back(i); 
	}
    
    for(int i = 1 ; i <= t ; i ++ )
     for(int j = m ; j >= 0 ; j -- )
      for(int k = 1 ; k <=bag[i].size()  ; k ++ )
       if(j >= w[bag[i][k - 1]])
       dp[j] = max(dp[j] , dp[j - w[bag[i][k - 1]]] + v[bag[i][k - 1]]);
       
    cout<<dp[m];
	return 0;
}

货币系统

【问题描述】

给你一个n种面值的货币系统，求组成面值为m的货币有多少种方案。

其中1 <= n<= 100，1<=m<=10000

【输入形式】

第1行：两个数n（表示面值的种数），m（表示n种面值组成的总面值）

接下来n行，每行一个数，表示一种面值

【输出形式】

n种面值组成面值为m的货币的方案数。

【样例输入】

3 10

【样例输出】

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int n , m,v;
ll dp[MAX];

int main(){  
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m;
    dp[0] = 1;
    for(int i = 1 ; i <= n ; i ++ ){
    	 cin >> v;
    	 for(int j = v ; j <= m ; j ++)
    	  dp[j] += dp[j - v] ;
	}
	cout<<dp[m];
	return 0;
}

对抗赛(compete)

【问题描述】

程序设计对抗赛设有N（0<N≤50的整数）个价值互不相同的奖品，每个奖品的价值分别为S1，S2，S3……Sn（均为不超过100的正整数）。现将它们分给甲乙两队，为了使得甲乙两队得到相同价值的奖品，必须将这N个奖品分成总价值相等的两组。

编程要求：对给定N及N个奖品的价值，求出将这N个奖品分成价值相等的两组，共有多少种分法？

例如：N = 5，S1，S2，S3……Sn分别为1，3，5，8，9

则可分为{1，3，9}与{5，8}

仅有1种分法；

例如：N = 7，S1，S2，S3……Sn分别为1，2，3，4，5，6，7

则可分为：

{1,6,7}与{2,3,4,5}

{2,5,7}与{1,3,4,6}

{3,4,7}与{1,2,5,6}

{1,2,4,7}与{3,5,6}

有4种分法。

【输入形式】

输入文件中包含N及S1，S2，S3……Sn。（每两个相邻的数据之间有一个空格隔开）。

【输出形式】

输出文件包含一个整数，表示多少种分法的答案，数据若无解，则输出0。

【样例输入】

1 2 3 4 5 6 7

【样例输出】

//#pragma GCC optimize(1)
//#pragma GCC optimize(2)
//#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int m,n,t;
int a[MAX];
int num[105];
int dp[MAX];
int v[MAX],w[MAX];

int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n ;
    for(int i = 1 ; i <= n ; i ++) cin >> a[i],m += a[i]; 
    if (m&1)
    {
        cout<<"0";
        return 0;
    }
    m>>=1;
    dp[0] = 1;
    for(int i = 1 ; i <= n ; i ++ )
        for (int j = m;j >= a[i]; j--)
            dp[j] += dp[j - a[i]];
    cout<<dp[m]/2;

	return 0;
}

演讲大厅安排(hall)

【问题描述】

有一个演讲大厅需要我们管理，演讲者们事先定好了需要演讲的起始时间和中止时间。我们想让演讲大厅得到最大可能的使用。我们要接受一些预定而拒绝其他的预定，目标是使演讲者使用大厅的时间最长。假设在某一时刻一个演讲结束，另一个演讲就可以立即开始。

编程任务,计算演讲大厅最大可能的使用时间。

【输入形式】

输入文件hall.in第一行为一个整数N，N≤5000，表示申请的数目。

以下n行每行包含两个整数p，k，1 ≤ p < k ≤ 30000，表示这个申请的起始时间和中止时间。

【输出形式】

一个整数，表示大厅最大可能的使用时间。

【样例输入】

1 2

3 5

0 4

6 8

7 13

4 6

9 10

9 12

11 14

15 19

14 16

18 20

【样例输出】

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 
int n,dp[MAX];
struct Node{
   int l ,r;
   bool operator <(const Node &x) const{
   	 return x.r > r;
   }	
}a[MAX];

int main(){  
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n;
    for(int i = 1 ; i <= n ; i ++) cin >> a[i].l >> a[i].r ;
    sort(a + 1 , a + 1 + n);
    
    for(int i = 1 ; i <= n ; i++ )
     for(int j = a[n].r ; j >= a[i].r ; j --)
      dp[j] = max(dp[j],dp[a[i].l] + a[i].r - a[i].l );
    cout<<dp[a[n].r ];
	return 0;
}

火车票(railway)

【问题描述】

从Ekaterinburg到Sverdlovsk的火车线路上有若干个站点。这条线路可以近似的表示为一条线段，火车站就是线段上的点。线路始于Ekaterinburg，终于Sverdlovsk。Ekaterinburg被标号为1，Sverdlovsk被标号为n。（n为整条线路上的站点数）

在这里插入图片描述

线路上的任意两个站点间的直达票价是由它们间的距离决定的，票价根据以下规则制定：

如果两站的间距超过L3，则无直达车票。所以有时可能有必要买多张票，通过转车的方式，从一个站到达另一个站。

例如，在上面的图中，有7个站点。2号站点到6号站点的距离超过L3，不能买直达票。存在若干种中转的方法，其中的一种是买两张票：先花费C2从2号站到达3号站，然后花费C3从3号站到6号站，一种花费C2+C3。

你的任务是，找出一种最经济的中转方案。

【输入形式】

第一行 6个整数L1, L2, L3, C1, C2, C3（1<=L1<L2<L3<=10^9, 1<=C1<C2<C3<=10^9），中间用空格分隔。

第二行一个整数n（2<=n<=100），表示线路上的车站数。

第三行两个整数s和t，分别是起点和终点的编号。注意：s不一定小于t。

以下的n-1行，按据Ekaterinburg远近，每行描述了一个车站的位置。它包含一个整数，表示该车站距Ekaterinburg的距离。

任意两个车站的距离不超过10^9，任意两个相邻的车站的距离不超过L3。

【输出形式】

一个整数，表示从给定的一个站到给定的另一个站的最小花费。

【样例输入】

3 6 8 20 30 40

2 6

【样例输出】

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

ll l1,l2,l3,c1,c2,c3,n,s,t,a[MAX];
ll dp[1005][1005],dis[MAX];
ll fun(int x,int y)
{
    ll tmp=abs(dis[x]-dis[y]);
	if(tmp>0&&tmp<=l1) return c1;
	else if(tmp>l1&&tmp<=l2) return c2;
	else if(tmp>l2&&tmp<=l3) return c3;
	return inf;
	

}
int main(){  
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> l1 >> l2 >> l3 >> c1 >> c2 >> c3;
    cin >> n >> s >> t;
    dis[1] = 0;
    
    for(int i = 2 ; i <= n ; i++ ) cin >> dis[i];
    
    for(int i = 1 ; i <= n ; i++ )
     for(int j = i; j <= n ; j ++)
      dp[i][j] = dp[j][i] = fun(i,j);
      
    for( int k = 1 ; k <= n ; k++)
     for( int i = 1 ; i <= n ; i++)
        for( int j = 1 ;j <= n ; j++)
               dp[i][j] = min(dp[i][j],dp[i][k]+dp[k][j]);
            
    cout<<dp[s][t];
	return 0;
}

单词的划分(word)

【问题描述】

有一个很长的由小写字母组成字符串。为了便于对这个字符串进行分析，需要将它划分成若干个部分，每个部分称为一个单词。出于减少分析量的目的，我们希望划分出的单词数越少越好。你就是来完成这一划分工作的。

【输入形式】

第一行，一个字符串。（字符串的长度不超过100）

第二行一个整数n，表示单词的个数。（n<=100）

第3~n+2行，每行列出一个单词。

【输出形式】

一个整数，表示字符串可以被划分成的最少的单词数。

【样例输入】

realityour

real

reality

your

our

【样例输出】

2
【样例说明】

（原字符串可拆成real+it+your或reality+our，由于reality+our仅为两个部分，因此最优解为2，另外注意，单词列表中的每个单词都可以重复使用多次，也可以不用）

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=998244353;
const int MAX=3e6+10;
const int Time=86400;
const int X=131;
const ll inf=0x7f7f7f7f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

string a[MAX],str;
int dp[MAX]; 
int n;

int main(){  
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> str;
    cin >> n;
    for(int i = 0 ; i < n ; i ++ ) cin >> a[i];
    memset(dp,inf,sizeof dp);
    dp[0] = 0;
    for(int i = 0 ; i < str.size() ; i ++ ){
    	int k = i + 1;
    	 for(int j = 0 ; j < n ; j ++ ){
    	 	  int len = a[j].size() ;
    	 	  if(len > k) continue;
    	 	   else{
    	 	   	   if(str.substr(k - len , len) == a[j]) dp[k] = min(dp[k],dp[k - len] + 1);
				}
		 }
	}
	cout<<dp[str.size() ];
    return 0;
}