关于微信小程序使用JavaScript求解背包问题

最新推荐文章于 2023-06-21 16:31:07 发布
最新推荐文章于 2023-06-21 16:31:07 发布
阅读量162 收藏 3
点赞数
文章标签： 微信小程序 javascript 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maacli/article/details/130128767
版权

背包问题求解

拟解决生活中常见的问题之一：背包问题

该问题要求在一个物品集合中选择合适的物品放入背包，在放入背包中的物品总重量不超过背包容量的前提下，希望放入背包的物品总价值最大。根
据是否允许部分物品放入背包的要求，背包问题可以分为分数背包问
题和 0-1 背包问题。
对于分数背包问题，可以通过设计贪心算法得到问题实例的最优
解。对于 0-1 背包问题，该问题已经被证明为 NP-Hard，即不存在多
项式时间算法那求解，但可以通过贪心算法得到问题的近似解，或者
通过蛮力法、动态规划法得到问题的最优解。能分析各个算法所
使用的算法设计技术和时间复杂度。下列基本要求必须完成：
1、设计一个交互界面（例如菜单）供用户选择，如果可能，最好是
一个图形化用户界面；
2、能够人工输入一个背包问题具体实例，涉及物品个数、每个物品
的重量和价值，以及背包容量；
3、设计一个贪心算法求解分数背包问题给定实例的最优解，并分析
算法的时间复杂度；
4、设计一个贪心算法求解 0-1 背包问题给定实例的近似解，请提供
一个反例判断该算法不能总是能够给出最优解，并证明算法的解
和最优解的值的比值大于等于 1/2。
5、设计一个蛮力法算法求解 0-1 背包问题给定实例的最优解，并分
析算法的时间复杂度；
6、设计一个动态规划算法求解求解 0-1 背包问题给定实例的最优解，
并分析算法的时间复杂度；

wxml

<view class="box1">
  <text>请输入数量：</text>
  <input bindinput="numberInput"/>
  <text>请输入重量：</text>
  <input bindinput="weightInput"/>
  <text>请输入价值：</text>
  <input bindinput="valueInput"/>
  <text>请输入背包重量：</text>
  <input bindinput="maxWeightInput"/>
</view>
<view class="box4">
  <view>贪心法求分数背包</view>
  <text>{{total}}</text>
  <button type="primary" size="mini" class="btn2" bindtap="callTanxin_score">按我</button>
</view>
<view class="box4">
  <view>动态规划求01背包</view>
  <text>{{total1}}</text>
  <button type="primary" size="mini" class="btn2" bindtap="callKnapscak">按我</button>
</view>
<view class="box4">
  <view>穷举法求01背包</view>
  <text>{{total2}}</text>
  <button type="primary" size="mini" class="btn2" bindtap="callBruteForce">按我</button>
</view>
<view class="box4">
  <view>贪心法求01背包</view>
  <text>价值：{{total3}}</text>
  <text>重量:{{total3weight}}</text>
  <button type="primary" size="mini" class="btn2" bindtap="callTanxin_01">按我</button>
</view>

wxss

/* pages/home/home.wxss */
page{
  background: #eeeeee;
}
.show_array{
  min-height: 80rpx;
  width: 720rpx;
  line-height: 40rpx;
  word-wrap: break-word;
  word-break: break-all;
  padding: 12rpx 0;
  letter-spacing: 2rpx;
}
.box1{
  width: 704rpx;
  padding-left: 40rpx;
  padding-top: 10rpx;
  border-radius: 12rpx;
  background: #ffffff;
  margin: 14rpx auto;
  padding-bottom: 20rpx;
  font-size: 30rpx;
  line-height: 40rpx;
  color: #141414;
}
.box4{
  height: 130rpx;
  width: 704rpx;
  padding-left: 40rpx;
  padding-top: 10rpx;
  border-radius: 12rpx;
  background: #ffffff;
  margin: 14rpx auto;
  /* padding-bottom: 20rpx; */
  font-size: 30rpx;
  line-height: 40rpx;
  color: #141414;
}
.btn2{
  position: absolute;
  right: 30rpx;
}
.box4 text{
  display: inline-block;
  margin-right:40rpx;
}

js

Page({
  /**
   * 页面的初始数据
   */
  data: {
    number:0,
    weight:[],
    value:[],
    maxWeight:0,
    selected : [],
    F:[],
    total:'',//贪心分数
    total1:'',//动态规划
    total2:'',//穷举
    total3:'',//贪心01
    total3weight:'',//贪心01总重量
  },
numberInput(e){
  let testarray=e.detail.value
  this.data.number=parseInt(testarray) 
},
weightInput(e){
  let testarray=e.detail.value
  // this.data.weight=testarray.split(",")
  let nums=testarray.split(",")
  var turnNum=function(){
    for(let i=0;i<nums.length;i++){
      nums[i]=parseInt(nums[i])
    }
    return nums
  }
  this.data.weight=turnNum()
},
valueInput(e){
  let testarray=e.detail.value
  // this.data.value=testarray.split(",")
  let nums=testarray.split(",")
  var turnNum=function(){
    for(let i=0;i<nums.length;i++){
      nums[i]=parseInt(nums[i])
    }
    return nums
  }
  this.data.value=turnNum()
},
maxWeightInput(e){
  let testarray=e.detail.value
  this.data.maxWeight=testarray
},
// 贪心算法求分数背包  
		//贪心算法，只能算，可以分割的物品，如果不能分割物品，只能得到近似解，不分割物品，可以使用动态规划
		//1、计算每件商品的（价格/质量），即单位质量的价值
		//2、将单位质量价值排序
tanxin_score:function (){
  // let weights=[2,2,6,5,4]
  // let values=[6,3,5,4,6]
  // let capacity=10
  let weights=this.data.weight
  let values=this.data.value
  let capacity=this.data.maxWeight
	var list  = [];
	for(var i = 0,len = weights.length; i < len; i++){
		list.push({
			num:i+1,  //第几件商品
			w:weights[i], //重量
			v:values[i],
			rate:values[i]/weights[i]  
		});
	}
	list.sort(function(a,b){
		if(a.rate  > b.rate){
			return -1;
		}else{
			return 1;
		}
	});
	var selects = [];
	var total = 0;
	for(var i = 0,len = list.length; i < len; i++){
		var item = list[i];
		if(item['w'] <= capacity){
			selects.push({
				num:item.num,
				rate:1 ,       //完整的商品记录为1
				v:item.v,
				w:item.w
			});
			total = total + item.v;
			capacity = capacity - item.w;
		}else if(capacity > 0){
			//选取不完整的商品
			var rate = capacity/item['w'];
			var v = item.v*rate;
			selects.push({
				num:item.num,
				rate: rate,
				v:item.v*rate,
				w:item.w*rate
			});
			total = total + v;
			break;
		}else{
			break;
		}
	}
	return {
		selects,
		total
	}
},
callTanxin_score:function(){
  console.log(this.tanxin_score())
  this.setData({
    total:this.tanxin_score().total
  })
},
// 动态规划
knapsack:function (){
  let weights=this.data.weight
  let values=this.data.value
  let W=this.data.maxWeight
  var n = weights.length -1
  var f = [[]]  //记录结果矩阵
  for(var j = 0; j <= W; j++){
      if(j < weights[0]){ //如果容量不能放下物品0的重量，那么价值为0
         f[0][j] = 0
      }else{ //否则等于物体0的价值
         f[0][j] = values[0]
      }
  }
  for(var j = 0; j <= W; j++){
      for(var i = 1; i <= n; i++ ){
          if(!f[i]){ //创建新一行
              f[i] = []
          }
          if(j < weights[i]){ //等于之前的最优值
              f[i][j] = f[i-1][j]
          }else{
              f[i][j] = Math.max(f[i-1][j], f[i-1][j-weights[i]] + values[i]) 
          }
      }
      
  }
  console.log(f.concat())
  return f[n][W]
},
callKnapscak:function(){
  // this.knapsack()
  this.setData({
    total1:this.knapsack()
  })
},
// 递归
BFknapsack:function (n, W, weights, values, selected) {
  if (n == 0 || W == 0) {
      //当物品数量为0，或者背包容量为0时，最优解为0
      return 0;
  } else {
      //从当前所剩物品的最后一个物品开始向前，逐个判断是否要添加到背包中
      for (var i = n - 1; i >= 0; i--) {
          //如果当前要判断的物品重量大于背包当前所剩的容量，那么就不选择这个物品
          //在这种情况的最优解为f(n-1,C)
          if (weights[i] > W) {
              return this.BFknapsack(n - 1, W, weights, values, selected);
          } else {
              var a = this.BFknapsack(n - 1, W, weights, values, selected); //不选择物品i的情况下的最优解
              var b = values[i] + this.BFknapsack(n - 1, W - weights[i], weights, values, selected); //选择物品i的情况下的最优解
              //返回选择物品i和不选择物品i中最优解大的一个
              if (a > b) {
                  selected[i] = 0; //这种情况下表示物品i未被选取
                  return a;
              } else {
                  selected[i] = 1; //物品i被选取
                  return b;
              }
          }
      }
  }
},  
callBFknapsack:function(){
  let selected=this.data.selected
  let ws=[2,2,6,5,4]
  let vs=[6,3,5,4,6]
  console.log(this.BFknapsack(5,10,ws,vs,selected))
  selected.forEach(function(el,i){
  if(el){
      console.log("选择了物品"+i+ " 其重量为"+ ws[i]+" 其价值为"+vs[i])
  }
})
},
// 背包问题记忆化
MFKnapsack:function(i,j,F){
  var value = 0;
  // let F=this.data.F
  if(F[i][j] < 0){
    if (j < parseInt(this.pws[i])){
      value = this.MFKnapsack(i-1,j,F)
    }else{
      value = this.max(this.MFKnapsack(i-1,j,F),parseInt(this.pvs[i])+this.MFKnapsack(i-1,j-parseInt(this.pws[i]),F))
    }
    this.F[i][j] = value;
  }
  return this.F[i][j],F;
},
//求最大值
max:function(a,b){
  if(a>b){
    return a;
  }else{
    return b;
  }
},
//背包问题主函数
backpackmain:function(){
  // let pws=[2,2,6,5,4]
  // let pvs=[6,3,5,4,6]
  let pws=this.data.weight
  let pvs=this.data.value
  let F=this.data.F
  let pweight=''
  let pvalue=''
  let backpackweight=''
  let ts=[]
  //pws和pvs首端添加0，因为背包的记忆功能算法使用的是Weights[1..n]和Valuess[1..n]
  pws=pws.splice(0,0,0);
  pvs=pvs.splice(0,0,0);
  F = new Array(pws.length);
  //初始化值
  for (var i = 0; i < pws.length; i++) {
    F[i] = new Array(parseInt(backpackweight)+1)
    for (var j = 0; j <= parseInt(backpackweight); j++) {
      if(i==0 || j==0){
        F[i][j] = 0;
      }else{
        F[i][j] = -1;
      }
    }
  }
  this.MFKnapsack(pws.length -1,parseInt(backpackweight),F)
  //输出最优子集
   things = new Array();
  var j = parseInt(backpackweight);
  for (var i = pws.length-1; i > 0; i--) {
    if(F[i][j] == F[i-1][j]){
      while(F[i][j] == F[i-1][j]){
        i--;
      }
    }
    ts.push(i)
    j = j - pws[i];
  }
  console.log(F)
  console.log(ts)
},
// 穷举法
bruteForce:function(){
  // let weights=[7,3,4,5]
  // let values=[42,12,40,25]
  // let W=10
  // let n=4    
  let weights=this.data.weight
  let values=this.data.value
  let W=this.data.maxWeight
  let n=this.data.number
  let height= Math.pow(2,n)
  var arr =Array(height).fill().map(() => Array(n))
  for(var i =0;i <height;i++){  //总共有2^n个子集，需要进行2^n次循环，及数组A有2^n行
      var temp1 = i;
      for(var j =0;j < n;j++){    //数组A有n列，每一列代表一个物品
        var temp2 = parseInt(temp1 % 2);
        arr[i][j] = temp2;
        temp1 =parseInt(temp1 / 2);
      }
  }
  this.printArray(arr,weights,values,W);
  let maxSumValue=this.printArray(arr,weights,values,W)
  return maxSumValue
},
//输出穷举方案的背包实例的选择物品（0代表不包含该物品，1表示包含该物品）的总重量及总价值，并输出最优实例的总价值
printArray:function(arr,weight,value,maxWeight){
  // let arr = new Array(16).fill(new Array(4).fill(0))
  let len1 = arr.length      //二维数组的行数
  let len2 = arr[0].length      //二维数组的列数
  let maxSumValue=0
  for(let i=0;i<len1;i++){
      let tempWeight = 0;      //暂时计算当前选中背包实例物品的总重量，初始化为0
      let tempSumValue = 0;    //暂时计算当前选中背包实例物品的总价值，初始化为0
      let result=" "
      for(let j = 0;j < len2;j++){
        result+=arr[i][j]+" "
        tempWeight += arr[i][j]*weight[j]
        tempSumValue += arr[i][j]*value[j]
      }
      console.log(result)
      console.log("\t"+"总重量为："+tempWeight);
      if(tempWeight <= maxWeight){
         console.log("\t"+"总价值为："+tempSumValue)
      }
      else{
        console.log("\t"+"不可行（超出背包最大承重）")
      }
      if(tempWeight <= maxWeight && tempSumValue > maxSumValue)
          maxSumValue = tempSumValue;
      console.log();
  }
  console.log("穷举查找得知，最优解的总价值为："+maxSumValue);
  return maxSumValue
},
callBruteForce:function(){
  this.bruteForce()
  this.setData({
    total2:this.bruteForce()
  })
},
//贪心法求01背包
//求价值
tanxin_01:function() {
  // let weights=[35, 30, 60, 50, 40, 10, 25]
  // let values=[10, 40, 30, 50, 35, 40, 30]
  // let W=150
  let weights=this.data.weight
  let values=this.data.value
  let W=this.data.maxWeight
  let n=this.data.number
  //存储累加的重量和价值
  let maxZhong=0;
  let maxJia=0;
  //存放密度
  let midu=new Array(n)
  //存放索引的数组
  let index=new Array(n)
  for (let i = 0; i < midu.length; i++)
  {
    midu[i]=parseFloat(values[i]/weights[i]);	
    index[i]=i;
  }
  //冒泡排序
  for (let i = 0; i < midu.length-1; i++)
  {
    for (let j = 0; j < midu.length-1-i; j++)
    {
      if (midu[j]<midu[j+1])
      {
        let temp =parseFloat(midu[j]);
        midu[j]=midu[j+1];
        midu[j+1]=temp;
        //索引跟着交换
        let temp1=index[j];
        index[j]=index[j+1];
        index[j+1]=temp1;
      }
    }
  }
  //计算最优解
  for (let i = 0; i < index.length; i++)
  {
    if (weights[index[i]]<=W)
    {
      maxZhong+=weights[index[i]];
      maxJia+=values[index[i]];
      W-=weights[index[i]];
    }
  }
  console.log("总重量："+maxZhong);
  console.log("总价值："+maxJia);
  return {maxZhong,maxJia}
},
callTanxin_01:function(){
  this.tanxin_01()
  this.setData({
    total3:this.tanxin_01().maxJia,
    total3weight:this.tanxin_01().maxZhong
  })
},

})
小码哥喝茶还是喝咖啡
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法设计-贪心算法-背包问题
06-04
背包问题.本算法比较清晰，易读。运行后自动出结果。 背包问题是比较经典的算法。很具有代表性。在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。
javascript解决背包问题
段郎的博客
11-15 810
背包问题： 给定 n 种物品和一个容量为 C 的背包，物品 i 的重量是 w[i]，其价值为 v[i] 。 问：应该如何选择装入背包的物品，使得装入背包中的物品的总价值最大？ 分析： n种物品，每一种要么放入背包，要么不放（在背包装不下的情况不放） 解决： 使用一个数组temp来存储当面对第i件商品，背包容积为j时的最大价值，我们很容易分析出temp的计算规则： 1）、当第i件商品的...
算法篇——动态规划 01背包问题 (js版)
XZZXBC的博客
06-20 927
更新一部分新题~
背包问题的 javascript和java 实现
霖林烟雨
10-08 2436
简述： 一个背包，
算法篇——动态规划 完全和多重背包问题 (js版)
XZZXBC的博客
06-21 1306
完全背包问题
基于JavaScript的微信小程序前端模板
03-06
2. **微信小程序框架**：微信小程序提供了自己的框架，该框架基于JavaScript，但引入了WXML（微信小程序标记语言）和WXSS（微信小程序样式语言）。WXML负责页面结构，类似于HTML，而WXSS则处理样式，类似于CSS。 3....
有关微信小程序如何使用mathjs
最新发布
11-15
mathjs9.3.2
微信小程序 实例汇总 完整项目源代码
11-01
3. **数据绑定**：微信小程序使用MVVM（Model-View-ViewModel）模式，通过双括号{{}}实现数据绑定，实时更新视图。数据模型的改变会自动反映到视图层。 4. **API调用**：微信小程序提供了丰富的API接口，如网络请求...
uniapp,微信小程序中使用 MQTT的问题
10-15
在uniapp和微信小程序中使用MQTT，主要依赖于JavaScript实现的MQTT客户端库，如mqtt.js。 1. **MQTT.js**：这是一个JavaScript编写的MQTT客户端库，不仅适用于Node.js环境，还支持浏览器环境，包括微信小程序。在...
0-1背包问题需对容量为c 的背包进行装载。从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高。
08-13
输入： 多个测例，每个测例的输入占三行。第一行两个整数：n（n<=10）和c，第二行n个整数分别是w1到wn，第三行n个整数分别是p1到pn。 n 和 c 都等于零标志输入结束。 输出： 每个测例的输出占一行，输出一个整数，即最佳装载的总价值。 输入样例： 1 2 1 1 2 3 2 2 3 4 0 0 输出样例： 1 4
算法实验代码和报告（时间复杂度、0-1背包问题、分治与贪心、蛮力法）
02-24
算法实验代码和报告（时间复杂度、0-1背包问题、分治与贪心、蛮力法）。
背包问题
smile_study1的博客
06-10 268
01背包 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 import java.util.Scanner; public class Main
详解动态规划01背包问题--JavaScript实现
包磊磊的博客
06-09 477
对其他动态规划问题感兴趣的，也可以查看 详解动态规划最少硬币找零问题--JavaScript实现 详解动态规划最长公共子序列--JavaScript实现 一开始在接触动态规划的时候，可能会云里雾里，似乎能理解思路，但是又无法准确地表述或者把代码写出来。本篇将一步一步通过作图的方式帮助初次接触动态规划的同学来理解问题。这一篇将以经典的 01背包 问题为例子来讲解，最后通过纯 JavaScript 来实现，在 Sublime 上运行演示。当然如果不会 JavaScript 也一点关系都没有，因为最重要的是
贪心算法续（01背包）
sensern的博客
11-22 193
01背包 动态规划 递归
最通俗的语言解释01背包问题(力扣416题javascript版本）
qq_41040989的博客
04-19 524
其实写到这里很多人都无法理解为啥突然就是这样子的（尤其逻辑性很强的同学(狗头）），下面具体分析一下，为什么是这样，我的推荐是先记住，然后通过下面的分析知道为什么就可以，自己从0到1推真的很难。这个数组乍一看还是有点云里雾里，其实这里就是用一个二维数组去遍历所有的情况，每个空格表示当前情况下的最大的价值总和，比如。先来看一个场景：有N件物品，背包最大的重量为W，第i件物品的重量为weight[i]，得到的价值为value[i]，像上面这样的问题，其实就是经典的01背包问题，那01背包问题。
贪心算法求解背包问题
二琳爱吃肉的博客
05-26 4751
1.实验要求 用贪心策略设计并实现一个贪心算法，求解背包问题。 2.算法基本思想 每次找未装包的物品中单位重量价值最大的物品装包，装包的同时也要考虑到背包的剩余容量。 3.主要数据结构及其作用 动态数组：存储数据 4.测试用例 5.实验结果截图 测试用例1 测试用例2 测试用例3 6.代码实现 #include<iostream> using namespace std; int main(){ int c,n; cout<<"请输入背包的容量c:"; cin>&
分数背包问题(贪心算法)
YYC的专栏
12-05 8234
#include #include #include #include using namespace std; /* *分数背包问题(贪心算法) */ struct goods { double value;//物品的价值 double weight;//物品的重量 double ratio;//物品的性价比 double in;//物品装入背包的重量 int index;/
微信小程序驱动的餐厅点餐系统设计与实现
本篇毕业论文主要探讨了基于微信小程序的点餐系统的设计与实现。微信作为一款广泛应用的即时通讯工具，自2011年诞生以来，其小程序功能因其便捷性与轻量化特性得到了迅速普及。本文研究的焦点在于利用微信小程序为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值