算法设计与分析

01背包的各种求解算法

题目详情

有 N 件物品和一个容量是 V 的背包。每件物品有且只有一件。第 i 件物品的重量是w[i] ，价值是v[i] 。

求解将哪些物品装入背包，可使这些物品的总重量不超过背包容量，且总价值最大

蛮力枚举

方法：找出枚举范围，约束条件

int cw,cv,n,capacity;
int end_state[N],c_state[N];
int v[N],w[N];

int f(int i)
{
	if(i>n-1)
	{
		if(ans<cv&&cw<capacity)
		{
			for(int i=0;i<n;i++)
			end_state[i]=c_state[i];
			ans=cv;
		}
		return ans;
	}
	cw+=w[i];
	cv+=v[i];
	c_state[i]=1;
	f(i+1);
	cw-=w[i];
	cv-=v[i];
	c_state=[0];
	f(i+1);	
	return ans;
} 

动态规划

基本思想：

将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解

与分治法不同的是，适合于用动态规划法求解的问题，经分解得到的子问题往往不是相互独立的

该算法的有效性依赖于问题本身所具有的的两个重要性质：
最优子结构和 子问题重叠性质

最优子结构

设计动态规划算法的第一步通常是要刻画最优解的结构。当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。问题的最优子结构性质提供了该问题可用动态规划算法求解的重要线索。利用问题的最优子结构性质，以自底向上的方式递归地从子问题的最优解逐步构造出整个问题的最优解。

重叠子问题

可用动态规划算法求解的问题应具备的另一基本要素是子问题的重叠性质。在用递归算法自顶向下解此问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只解一次，而后将其解保存在一个表格中，当再次需要解此子问题时，只是简单地用常数时间查看一下结果。通常，不同的子问题个数随问题的大小呈多项式增长。因此，用动态规划算法通常只需要多项式时间，从而获得较高的解题效率。

解题步骤

状态定义

本质上就是从i个物品中选择一定数量的物品在一定空间限制的前提下，求这些物品的最大总价值，我们可以定义一个二维数组dp[i][j]，这个数组的值就表示从前i件物品进行选择，在不超过容量j的前提下所满足最大的物品总价值。（注：此处的第i件物品对应与数组下标i）

确定初始状态

当只有一个物品时，如果该物品的体积v不大于背包容量j，则初始值dp[0][j]=w[0]，否则dp[0][j]=0。

状态转移方程

对于第i件物品，设它的所占容量为v[i]，价值为w[i]，我们可以选择该物品也可以不选择该物品，如果不选择该物品则 d p [ i ] [ j ] = d p [ i − 1 ] [ j ] dp[i][j]=dp[i-1][j] dp[i][j]=dp[i−1][j]，如果选择该物品有两种情况：

背包剩余空间不够了，那么此时就无法选择该物品， d p [ i ] [ j ] = d p [ i − 1 ] [ j ] dp[i][j]=dp[i-1][j] dp[i][j]=dp[i−1][j]。
背包剩余空间充足，那么此时的物品总价值为 d p [ i ] [ j ] = d p [ i − 1 ] [ j − v [ i ] ] + w [ i ] dp[i][j]=dp[i-1][j-v[i]] + w[i] dp[i][j]=dp[i−1][j−v[i]]+w[i]。
综上，转移方程为 d p [ i ] [ j ] = m a x ( d p [ i − 1 ] [ j ] , d p [ i − 1 ] [ j − v [ i ] ] + w [ i ] ) dp[i][j]=max(dp[i-1][j],\ dp[i-1][j-v[i]]+w[i]) dp[i][j]=max(dp[i−1][j], dp[i−1][j−v[i]]+w[i])。

int DP(int n,int v[],int w[],int c)
{
	for(int i=0;i<=c;i++)
	{
		dp[0][i]=i>=w[0]?v[0]:0;
	}
	
	for(int i=1;i<n;i++)
	{
		for(int j=0;j<=c;j++)
		{
			//不选
			int x = dp[i-1][j];
			int y = j>=w[i]?dp[i-1][j-w[i]]+v[i]:0;
			dp[i][j]=max(x,y); 
		}
	}
	return dp[n-1][c];
	
}

分支限界

算法思想

首先，要对输入数据进行预处理，将各物品依其单位重量价值从大到小进行排列。
在实现时，由Bound计算当前结点处的上界。在解空间树的当前扩展结点处，仅当要进入右子树时才计算右子树的上界Bound，以判断是否将右子树剪。进入左子树时不需要计算上界，因为其上界与其父节点上界相同。
在优先队列分支限界法中，结点的优先级定义为：以结点的价值上界作为优先级（由bound函数计算出）

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
 
using namespace std;
 
struct item
{
    double v, w;
};
 
struct node
{
    int cw, cv, i;
    double B;
    node(int cv, int cw, int i, double B) : cv(cv), cw(cw), i(i), B(B) {}
    bool operator<(const node &b) const
    {
        return this -> B < b.B;
    }
};
 
int bestw = 0, N, V;
vector<item> items;
 
bool cmp(const item &a, const item &b)
{
    return a.w / a.v > b.w / b.v;
}
 
double evalue(int i, double cv)
{
    double upperbound = 0, vleft = V - cv;
    for(int k = i; k <= N; ++k)
    {
        if(vleft >= items[k].v)
        {
            upperbound += items[k].w;
            vleft -= items[k].v;
        }
        else
        {
            upperbound += items[k].w / items[k].v * vleft;
            return upperbound;
        }
    }
    return upperbound;
}
 
void Knapsacks()
{
    priority_queue<node> Q;
    Q.push(node(0, 0, 1, evalue(1, 0)));
    node temp(0, 0, 0, 0);
    while(!Q.empty())
    {
        temp =  Q.top();
        Q.pop();
        if(temp.i > N)
        {
            bestw = temp.cw;
            return;
        }
        double &vi = items[temp.i].v;
        double &wi = items[temp.i].w;
        double nextB = temp.cw + evalue(temp.i + 1, temp.cv);
        if(temp.cv + vi <= V)
        {
            Q.push(node(temp.cv + vi, temp.cw + wi, temp.i + 1, temp.B));
            bestw = bestw > temp.cw + wi ? bestw : temp.cw + wi;
        }
        if(nextB > bestw)
            Q.push(node(temp.cv, temp.cw, temp.i + 1, nextB));
    }
}
 
int main()
{
    scanf("%d%d", &N, &V);
    items.resize(N + 1);
    for(int i = 1; i <= N; ++i)
        scanf("%lf%lf", &items[i].v, &items[i].w);
    sort(items.begin() + 1, items.end(), cmp);
    Knapsacks();
    cout << bestw << endl;
    system("pause");
    return 0;
}

回溯法

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


#define N 100
int n;//物品数量
double c;//背包容量

double cw = 0.0;//当前背包重量　current weight
double cp = 0.0;//当前背包中物品总价值　current value
double bestp = 0.0;//当前最优价值best price
int put[100];//设置是否装入，为1的时候表示选择该组数据装入，为0的表示不选择该组数据
int end_state[N]={0};
struct goods
{
	int w,v,p;
}goods[N];


bool cmp(struct goods a,struct goods b)
{
	return a.p>b.p;
}

//按单位价值排序
void knapsack()
{
 
    for(int i=1;i<=n;i++)
        goods[i].p=goods[i].v/goods[i].w; //计算单位价值（单位重量的物品价值）
   	sort(goods,goods+n,cmp);
}
 
//回溯函数
void backtrack(int i)
{   //i用来指示到达的层数（第几步，从0开始），同时也指示当前选择玩了几个物品
    double bound(int i);
    if(i>n) //递归结束的判定条件
    {
    	if(cp>bestp)
        {
        	bestp=cp;
        	for(int i=1;i<=n;i++)
        	end_state[i]=put[i];
		}
        return;
    }
    //如若左子节点可行，则直接搜索左子树;
    //对于右子树，先计算上界函数，以判断是否将其减去
    if(cw+goods[i].w<=c)//将物品i放入背包,搜索左子树
    {
        cw+=goods[i].w;//同步更新当前背包的重量
        cp+=goods[i].v;//同步更新当前背包的总价值
        put[i]=1;
        backtrack(i+1);//深度搜索进入下一层
        cw-=goods[i].w;//回溯复原
        cp-=goods[i].v;//回溯复原
 	 	put[i]=0;
    }
    if(bound(i+1)>bestp)//如若符合条件则搜索右子树
        backtrack(i+1);
}
 
//计算上界函数，功能为剪枝
double bound(int i)
{   //判断当前背包的总价值cp＋剩余容量可容纳的最大价值<=当前最优价值
    double leftw= c-cw;//剩余背包容量
    double b = cp;//记录当前背包的总价值cp,最后求上界
    //以物品单位重量价值递减次序装入物品
    while(i<=n && goods[i].w<=leftw)
    {
        leftw-=goods[i].w;
        b+=goods[i].v;
        i++;
    }
    //装满背包
    if(i<=n)
        b+=goods[i].v/goods[i].w*leftw;
    return b;//返回计算出的上界
 
}
 
 
 
int main()
{
    int i;
    printf("请输入物品的数量和背包的容量：");
    scanf("%d%lf",&n,&c);
    /*printf("请输入物品的重量和价值：\n");
    for(i=1;i<=n;i++)
    {
        printf("第%d个物品的重量：",i);
        scanf("%lf",&w[i]);
        printf("第%d个物品的价值是：",i);
        scanf("%lf",&v[i]);
        order[i]=i;
    }*/
    printf("请依次输入%d个物品的重量:\n",n);
    for(i=1;i<=n;i++){
        cin>>goods[i].w;
    }
 
    printf("请依次输入%d个物品的价值:\n",n);
    for(i=1;i<=n;i++){
        cin>>goods[i].v;
    }
 
 
    knapsack();
    backtrack(1);
 
 
    printf("最优价值为：%lf\n",bestp);
    printf("需要装入的物品编号是：");
    for(i=1;i<=n;i++)
    {
        if(end_state[i]==1)
        cout<<i<<" ";
    }
    return 0;
}

分治算法

快速排序

int a[10]={0,1,5,7,2,4,10,11,24,9};

int partition(int a[],int low,int high)
{
	a[0]=a[low];
	while(log<high)
	{
		while(a[high]>=a[0]&&low<high)high--;
		a[low]=a[high];
		while(a[low]<=w[high]&&low<high)low++;
		a[high]=a[low];		
	}
	a[low]=a[0];
	return low;
}



void QuickSort(int a[],int low,high)
{
	int mid=partition(a,low,high);
	QuickSort(a,low,mid-1);
	QuickSort(a,mid+1,high);
}

贪心算法

贪心算法求解活动选择问题

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// 结构体表示活动
struct Activity {
    int start, finish;
};

// 按照结束时间非降序排序
bool compareActivities(Activity a, Activity b) {
    return (a.finish < b.finish);
}

// 贪心算法解决活动选择问题
void greedyActivitySelection(vector<Activity>& activities) {
    // 按照结束时间排序
    sort(activities.begin(), activities.end(), compareActivities);

    int n = activities.size();
    vector<int> selectedActivities;

    // 第一个活动总是被选中
    int i = 0;
    selectedActivities.push_back(i);

    // 遍历剩余活动
    for (int j = 1; j < n; j++) {
        // 如果当前活动的开始时间大于或等于上一个活动的结束时间，则选择当前活动
        if (activities[j].start >= activities[i].finish) {
            selectedActivities.push_back(j);
            i = j;
        }
    }

    // 输出选中的活动
    cout << "Selected activities are: ";
    for (int k : selectedActivities) {
        cout << k << " ";
    }
    cout << endl;
}

int main() {
    // 示例活动集合
    vector<Activity> activities = {
        {1, 2},
        {3, 4},
        {0, 6},
        {5, 7},
        {8, 9},
        {5, 9}
    };

    // 使用贪心算法解决活动选择问题
    greedyActivitySelection(activities);

    return 0;
}