package dp;
import java.math.BigDecimal;
import java.util.Vector;
public class dpTest {
//根据总重量m,计算哪些可以被选中。选中的项,其select属性为1
//根据总重量,求最大值
public void backpack(int m,Vector<Item> itemList){
//初始化数据
int n=itemList.size();//总数
int w[]=new int[n];//重量
int p[]=new int[n];//值
for(int i=0;i<n;i++)
{
Item item=itemList.get(i);
w[i]=item.amount;
p[i]=item.repay;
}
//c[i][v]表示前i件物品恰放入一个重量为m的背包可以获得的最大价值
int c[][]= new int[n+1][m+1];
for(int i = 0;i<n+1;i++)
c[i][0]=0;
for(int j = 0;j<m+1;j++)
c[0][j]=0;
//
for(int i = 1;i<n+1;i++){
for(int j = 1;j<m+1;j++){
//当物品为i件重量为j时,如果第i件的重量(w[i-1])小于重量j时,c[i][j]为下列两种情况之一:
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(w[i-1]<=j){
if(c[i-1][j]<(c[i-1][j-w[i-1]]+p[i-1]))
c[i][j] = c[i-1][j-w[i-1]]+p[i-1];
else
c[i][j] = c[i-1][j];
}else
c[i][j] = c[i-1][j] ;
}
}
//计算哪些可以被选中
//从最后一个状态记录c[n][m]开始逆推
for(int i = n;i>0;i--){
//如果c[i][m]大于c[i-1][m],说明c[i][m]这个最优值中包含了w[i-1](注意这里是i-1,因为c数组长度是n+1)
if(c[i][m]>c[i-1][m]){
Item item=itemList.get(i-1);
item.select =1;//为1的是被选择的
m-=w[i-1];
}
}
}
//根据总重量m,计算哪些可以被选中。选中的项,其select属性为1
//根据总重量,求最小值
public void backpackmin(int m,Vector<Item> itemList){
//初始化数据
int n=itemList.size();//总数
int w[]=new int[n];//重量
int p[]=new int[n];//值
for(int i=0;i<n;i++)
{
Item item=itemList.get(i);
w[i]=item.amount;
p[i]=item.repay;
}
//c[i][v]表示前i件物品恰放入一个重量为m的背包可以获得的最大价值
int c[][]= new int[n+1][m+1];
for(int i = 0;i<n+1;i++)
c[i][0]=999999999;
for(int j = 0;j<m+1;j++)
c[0][j]=999999999;
//
for(int i = 1;i<n+1;i++){
for(int j = 1;j<m+1;j++){
//当物品为i件重量为j时,如果第i件的重量(w[i-1])小于重量j时,c[i][j]为下列两种情况之一:
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(j<=w[i-1]){
//如果当前重量小于第i件物品时,比较当前物品和上一次的c[][]的值,取最小的
if (p[i-1]>c[i-1][j])
c[i][j]=c[i-1][j];
else
c[i][j]=p[i-1];
}
else { //如果当前重量大于第i件物品时,
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(c[i-1][j]>(c[i-1][j-w[i-1]]+p[i-1]))
c[i][j] = c[i-1][j-w[i-1]]+p[i-1];
else
c[i][j] = c[i-1][j];
}
}
}
//计算哪些可以被选中
//从最后一个状态记录c[n][m]开始逆推
for(int i = n;i>0;i--){
//如果c[i][m]小于c[i-1][m],说明c[i][m]这个最优值中包含了w[i-1](注意这里是i-1,因为c数组长度是n+1)
//m>-1
if (m>0)
{
if(c[i][m]<c[i-1][m]){
Item item=itemList.get(i-1);
item.select =1;//为1的是被选择的
m-=w[i-1];
}
}
}
}
public int [][] pack(int m,int n,int w[],int p[]){
//c[i][v]表示前i件物品恰放入一个重量为m的背包可以获得的最大价值
int c[][]= new int[n+1][m+1];
for(int i = 0;i<n+1;i++)
c[i][0]=0;
for(int j = 0;j<m+1;j++)
c[0][j]=0;
//
for(int i = 1;i<n+1;i++){
for(int j = 1;j<m+1;j++){
//当物品为i件重量为j时,如果第i件的重量(w[i-1])小于重量j时,c[i][j]为下列两种情况之一:
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(w[i-1]<=j){
if(c[i-1][j]<(c[i-1][j-w[i-1]]+p[i-1]))
c[i][j] = c[i-1][j-w[i-1]]+p[i-1];
else
c[i][j] = c[i-1][j];
}else
c[i][j] = c[i-1][j] ;
}
}
return c;
}
public int [][] packmin(int m,int n,int w[],int p[]){
//c[i][v]表示前i件物品恰放入一个重量为m的背包可以获得的最大价值
int c[][]= new int[n+1][m+1];
for(int i = 0;i<n+1;i++)
c[i][0]=99999999;
for(int j = 0;j<m+1;j++)
c[0][j]=99999999;
//
for(int i = 1;i<n+1;i++){
for(int j = 1;j<m+1;j++){
//当物品为i件重量为j时,如果第i件的重量(w[i-1])小于重量j时,c[i][j]为下列两种情况之一:
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(j<=w[i-1]){
//如果当前重量小于第i件物品时,比较当前物品和上一次的c[][]的值,取最小的
if (p[i-1]>c[i-1][j])
c[i][j]=c[i-1][j];
else
c[i][j]=p[i-1];
}
else { //如果当前重量大于第i件物品时,
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(c[i-1][j]>(c[i-1][j-w[i-1]]+p[i-1]))
c[i][j] = c[i-1][j-w[i-1]]+p[i-1];
else
c[i][j] = c[i-1][j];
}
}
}
return c;
}
/**
* 逆推法求出最优解
* @param c
* @param w
* @param m
* @param n
* @return
*/
public int[] printPackmin(int c[][],int w[],int m,int n){
int x[] = new int[n];
//从最后一个状态记录c[n][m]开始逆推
for(int i = n;i>0;i--){
//如果c[i][m]小于c[i-1][m],说明c[i][m]这个最优值中包含了w[i-1](注意这里是i-1,因为c数组长度是n+1)
//m必须大于0
if (m>-1)
{
if(c[i][m]<c[i-1][m]){
x[i-1] = 1;
m-=w[i-1];
}
}
}
for(int j = 0;j<n;j++)
System.out.println(x[j]);
return x;
}
/**
* 逆推法求出最优解
* @param c
* @param w
* @param m
* @param n
* @return
*/
public int[] printPack(int c[][],int w[],int m,int n){
int x[] = new int[n];
//从最后一个状态记录c[n][m]开始逆推
for(int i = n;i>0;i--){
//如果c[i][m]大于c[i-1][m],说明c[i][m]这个最优值中包含了w[i-1](注意这里是i-1,因为c数组长度是n+1)
if(c[i][m]>c[i-1][m]){
x[i-1] = 1;
m-=w[i-1];
}
}
for(int j = 0;j<n;j++)
System.out.println(x[j]);
return x;
}
public int sumSelect(int x[],int p[]){
int sum=0;
for (int i=0;i<x.length;i++)
{
if (x[i]==1)
{
sum+=p[i];
}
}
return sum;
}
//计算调整后的比例
public double[] calc(int sum,int profit,int[] p)
{
double d1=sum-profit;
d1=d1/2;
d1=sum-d1;
double d=d1/sum;//计算收益和 需求的差值,并平均
//对进行调整后。
double pd[]=new double[p.length];
for (int i=0;i<pd.length;i++)
{
double f = p[i]*d;
BigDecimal b = new BigDecimal(f);
pd[i] = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
System.out.print(p[i]+" ");
System.out.println(pd[i]);
}
return pd;
}
//计算调整后的比例,返回结果为-1,无满足条件,大于0,则为实际值
public double makePrice(int profit,Vector<Item> itemList)
{
//先计算总值
int sum=0;
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1) sum=sum+item.repay ;
}
//如果实际大于等于预期,则选择有效
if (sum>=profit)
{
double d1=sum-profit;
d1=d1/2;
d1=sum-d1;
double d=d1/sum;//计算预期和实际的差值,并平均
//对预期进行调整。
double realIncome=0.0;
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1)
{
double f = item.repay*d;
BigDecimal b = new BigDecimal(f);
item.profit = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
realIncome=realIncome+item.profit ;
}
}
BigDecimal b1 = new BigDecimal(realIncome);
realIncome = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
//返回实际值
return realIncome;
}
else return -1;
}
//计算调整后的比例,返回结果为-1,无满足条件,大于0,则为实际值
//该函数用于 应付账单额度大,而买方(出资方)金额少,希望出资方的收益小于贴现额。
//profit为贴现额,sum为卖方收益,应该sum<profit
public double makePricemin(int profit,Vector<Item> itemList)
{
//先计算总值
int sum=0;
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1) sum=sum+item.repay ;
}
//如果收益小于贴现,则选择有效
if (sum<profit)
{
double d1=profit-sum;
d1=d1/2;
d1=sum+d1;
double d=d1/sum;//计算预期和实际的差值,并平均
//对预期进行调整。
double realIncome=0.0;
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1)
{
double f = item.repay*d;
BigDecimal b = new BigDecimal(f);
item.profit = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
realIncome=realIncome+item.profit ;
}
}
//返回实际值
BigDecimal b1 = new BigDecimal(realIncome);
realIncome = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
return realIncome;
}
else return -1;
}
public static void main(String args[]){
Vector<Item> itemList=new Vector<Item>();
Item sellItem=new Item();
sellItem.id="1";
sellItem.amount =20;
sellItem.repay =7;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="2";
sellItem.amount =10;
sellItem.repay =3;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="3";
sellItem.amount =15;
sellItem.repay =4;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="4";
sellItem.amount =16;
sellItem.repay =5;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="5";
sellItem.amount =17;
sellItem.repay =5;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="6";
sellItem.amount =25;
sellItem.repay =6;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="7";
sellItem.amount =22;
sellItem.repay =6;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="8";
sellItem.amount =21;
sellItem.repay =7;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="9";
sellItem.amount =20;
sellItem.repay =8;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="10";
sellItem.amount =30;
sellItem.repay =8;
itemList.add(sellItem);
int m = 100; //总重量
int repay=30;//预期贴现
dpTest pack = new dpTest();
pack.backpackmin(m, itemList);
double infact=pack.makePricemin(repay, itemList);
if (infact>0)
{
System.out.println("卖方预期贴现:"+repay+" ,实际贴现:"+infact);
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1)
System.out.println(item.id+":买方预期收益: "+item.repay+" 实际收益:"+item.profit);
}
}
else System.out.println("无匹配项! ");
/*
Vector<Item> itemList=new Vector<Item>();
Item sellItem=new Item();
sellItem.id="1";
sellItem.amount =1000;
sellItem.repay =32;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="2";
sellItem.amount =1000;
sellItem.repay =29;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="3";
sellItem.amount =1000;
sellItem.repay =33;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="4";
sellItem.amount =2000;
sellItem.repay =56;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="5";
sellItem.amount =2000;
sellItem.repay =60;
itemList.add(sellItem);
int m = 5000; //总量
int repay=150;//预期收益
dpTest pack = new dpTest();
pack.backpackmin(m, itemList);
double infact=pack.makePricemin(repay, itemList);
if (infact>0)
{
System.out.println("卖方预期贴现:"+repay+" ,实际贴现:"+infact);
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1)
System.out.println(item.id+":买方预期收益: "+item.repay+" 实际收益:"+item.profit);
}
}
else System.out.println("无匹配项! ");
*/
/*
int m = 100; //总重量
int n = 10; //数量,
int w[]={20,10,15,16,17,25,22,21,20,30}; //单个重量
int p[]={7,3,4,5,5,6,6,7,8,8}; //值
dpTest pack = new dpTest();
int c[][] = pack.pack(m, n, w, p);
int s[]= pack.printPack(c, w, m,n);
int sumselect=pack.sumSelect(s, p);
System.out.println(sumselect);
pack.calc(sumselect, 30, p);
*/
/* //求最小值
int m = 30; //总重量
int n = 9; //数量,
int w[]={2,5,3,6,4,8,7,9,9}; //单个重量
int p[]={8,15,15,14,15,10,30,10,9}; //值
dpTest pack = new dpTest();
int c[][] = pack.packmin(m, n, w, p);
pack.printPackmin(c, w, m,n);
int m = 30; //总重量
int n = 10; //数量,
//int w[]={3,4,5,6,7,8,9,10,11,12}; //单个重量
//int p[]={4,5,6,9,8,7,6,5,4,3}; //值
int w[]={3,4,5,6,7,8,9,10,11,12}; //单个重量
int p[]={4,5,6,9,8,7,6,5,4,3}; //值
dpTest pack = new dpTest();
int c[][] = pack.packmin(m, n, w, p);
pack.printPackmin(c, w, m,n);
*/
}
import java.math.BigDecimal;
import java.util.Vector;
public class dpTest {
//根据总重量m,计算哪些可以被选中。选中的项,其select属性为1
//根据总重量,求最大值
public void backpack(int m,Vector<Item> itemList){
//初始化数据
int n=itemList.size();//总数
int w[]=new int[n];//重量
int p[]=new int[n];//值
for(int i=0;i<n;i++)
{
Item item=itemList.get(i);
w[i]=item.amount;
p[i]=item.repay;
}
//c[i][v]表示前i件物品恰放入一个重量为m的背包可以获得的最大价值
int c[][]= new int[n+1][m+1];
for(int i = 0;i<n+1;i++)
c[i][0]=0;
for(int j = 0;j<m+1;j++)
c[0][j]=0;
//
for(int i = 1;i<n+1;i++){
for(int j = 1;j<m+1;j++){
//当物品为i件重量为j时,如果第i件的重量(w[i-1])小于重量j时,c[i][j]为下列两种情况之一:
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(w[i-1]<=j){
if(c[i-1][j]<(c[i-1][j-w[i-1]]+p[i-1]))
c[i][j] = c[i-1][j-w[i-1]]+p[i-1];
else
c[i][j] = c[i-1][j];
}else
c[i][j] = c[i-1][j] ;
}
}
//计算哪些可以被选中
//从最后一个状态记录c[n][m]开始逆推
for(int i = n;i>0;i--){
//如果c[i][m]大于c[i-1][m],说明c[i][m]这个最优值中包含了w[i-1](注意这里是i-1,因为c数组长度是n+1)
if(c[i][m]>c[i-1][m]){
Item item=itemList.get(i-1);
item.select =1;//为1的是被选择的
m-=w[i-1];
}
}
}
//根据总重量m,计算哪些可以被选中。选中的项,其select属性为1
//根据总重量,求最小值
public void backpackmin(int m,Vector<Item> itemList){
//初始化数据
int n=itemList.size();//总数
int w[]=new int[n];//重量
int p[]=new int[n];//值
for(int i=0;i<n;i++)
{
Item item=itemList.get(i);
w[i]=item.amount;
p[i]=item.repay;
}
//c[i][v]表示前i件物品恰放入一个重量为m的背包可以获得的最大价值
int c[][]= new int[n+1][m+1];
for(int i = 0;i<n+1;i++)
c[i][0]=999999999;
for(int j = 0;j<m+1;j++)
c[0][j]=999999999;
//
for(int i = 1;i<n+1;i++){
for(int j = 1;j<m+1;j++){
//当物品为i件重量为j时,如果第i件的重量(w[i-1])小于重量j时,c[i][j]为下列两种情况之一:
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(j<=w[i-1]){
//如果当前重量小于第i件物品时,比较当前物品和上一次的c[][]的值,取最小的
if (p[i-1]>c[i-1][j])
c[i][j]=c[i-1][j];
else
c[i][j]=p[i-1];
}
else { //如果当前重量大于第i件物品时,
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(c[i-1][j]>(c[i-1][j-w[i-1]]+p[i-1]))
c[i][j] = c[i-1][j-w[i-1]]+p[i-1];
else
c[i][j] = c[i-1][j];
}
}
}
//计算哪些可以被选中
//从最后一个状态记录c[n][m]开始逆推
for(int i = n;i>0;i--){
//如果c[i][m]小于c[i-1][m],说明c[i][m]这个最优值中包含了w[i-1](注意这里是i-1,因为c数组长度是n+1)
//m>-1
if (m>0)
{
if(c[i][m]<c[i-1][m]){
Item item=itemList.get(i-1);
item.select =1;//为1的是被选择的
m-=w[i-1];
}
}
}
}
public int [][] pack(int m,int n,int w[],int p[]){
//c[i][v]表示前i件物品恰放入一个重量为m的背包可以获得的最大价值
int c[][]= new int[n+1][m+1];
for(int i = 0;i<n+1;i++)
c[i][0]=0;
for(int j = 0;j<m+1;j++)
c[0][j]=0;
//
for(int i = 1;i<n+1;i++){
for(int j = 1;j<m+1;j++){
//当物品为i件重量为j时,如果第i件的重量(w[i-1])小于重量j时,c[i][j]为下列两种情况之一:
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(w[i-1]<=j){
if(c[i-1][j]<(c[i-1][j-w[i-1]]+p[i-1]))
c[i][j] = c[i-1][j-w[i-1]]+p[i-1];
else
c[i][j] = c[i-1][j];
}else
c[i][j] = c[i-1][j] ;
}
}
return c;
}
public int [][] packmin(int m,int n,int w[],int p[]){
//c[i][v]表示前i件物品恰放入一个重量为m的背包可以获得的最大价值
int c[][]= new int[n+1][m+1];
for(int i = 0;i<n+1;i++)
c[i][0]=99999999;
for(int j = 0;j<m+1;j++)
c[0][j]=99999999;
//
for(int i = 1;i<n+1;i++){
for(int j = 1;j<m+1;j++){
//当物品为i件重量为j时,如果第i件的重量(w[i-1])小于重量j时,c[i][j]为下列两种情况之一:
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(j<=w[i-1]){
//如果当前重量小于第i件物品时,比较当前物品和上一次的c[][]的值,取最小的
if (p[i-1]>c[i-1][j])
c[i][j]=c[i-1][j];
else
c[i][j]=p[i-1];
}
else { //如果当前重量大于第i件物品时,
//(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值
//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值
if(c[i-1][j]>(c[i-1][j-w[i-1]]+p[i-1]))
c[i][j] = c[i-1][j-w[i-1]]+p[i-1];
else
c[i][j] = c[i-1][j];
}
}
}
return c;
}
/**
* 逆推法求出最优解
* @param c
* @param w
* @param m
* @param n
* @return
*/
public int[] printPackmin(int c[][],int w[],int m,int n){
int x[] = new int[n];
//从最后一个状态记录c[n][m]开始逆推
for(int i = n;i>0;i--){
//如果c[i][m]小于c[i-1][m],说明c[i][m]这个最优值中包含了w[i-1](注意这里是i-1,因为c数组长度是n+1)
//m必须大于0
if (m>-1)
{
if(c[i][m]<c[i-1][m]){
x[i-1] = 1;
m-=w[i-1];
}
}
}
for(int j = 0;j<n;j++)
System.out.println(x[j]);
return x;
}
/**
* 逆推法求出最优解
* @param c
* @param w
* @param m
* @param n
* @return
*/
public int[] printPack(int c[][],int w[],int m,int n){
int x[] = new int[n];
//从最后一个状态记录c[n][m]开始逆推
for(int i = n;i>0;i--){
//如果c[i][m]大于c[i-1][m],说明c[i][m]这个最优值中包含了w[i-1](注意这里是i-1,因为c数组长度是n+1)
if(c[i][m]>c[i-1][m]){
x[i-1] = 1;
m-=w[i-1];
}
}
for(int j = 0;j<n;j++)
System.out.println(x[j]);
return x;
}
public int sumSelect(int x[],int p[]){
int sum=0;
for (int i=0;i<x.length;i++)
{
if (x[i]==1)
{
sum+=p[i];
}
}
return sum;
}
//计算调整后的比例
public double[] calc(int sum,int profit,int[] p)
{
double d1=sum-profit;
d1=d1/2;
d1=sum-d1;
double d=d1/sum;//计算收益和 需求的差值,并平均
//对进行调整后。
double pd[]=new double[p.length];
for (int i=0;i<pd.length;i++)
{
double f = p[i]*d;
BigDecimal b = new BigDecimal(f);
pd[i] = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
System.out.print(p[i]+" ");
System.out.println(pd[i]);
}
return pd;
}
//计算调整后的比例,返回结果为-1,无满足条件,大于0,则为实际值
public double makePrice(int profit,Vector<Item> itemList)
{
//先计算总值
int sum=0;
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1) sum=sum+item.repay ;
}
//如果实际大于等于预期,则选择有效
if (sum>=profit)
{
double d1=sum-profit;
d1=d1/2;
d1=sum-d1;
double d=d1/sum;//计算预期和实际的差值,并平均
//对预期进行调整。
double realIncome=0.0;
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1)
{
double f = item.repay*d;
BigDecimal b = new BigDecimal(f);
item.profit = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
realIncome=realIncome+item.profit ;
}
}
BigDecimal b1 = new BigDecimal(realIncome);
realIncome = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
//返回实际值
return realIncome;
}
else return -1;
}
//计算调整后的比例,返回结果为-1,无满足条件,大于0,则为实际值
//该函数用于 应付账单额度大,而买方(出资方)金额少,希望出资方的收益小于贴现额。
//profit为贴现额,sum为卖方收益,应该sum<profit
public double makePricemin(int profit,Vector<Item> itemList)
{
//先计算总值
int sum=0;
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1) sum=sum+item.repay ;
}
//如果收益小于贴现,则选择有效
if (sum<profit)
{
double d1=profit-sum;
d1=d1/2;
d1=sum+d1;
double d=d1/sum;//计算预期和实际的差值,并平均
//对预期进行调整。
double realIncome=0.0;
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1)
{
double f = item.repay*d;
BigDecimal b = new BigDecimal(f);
item.profit = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
realIncome=realIncome+item.profit ;
}
}
//返回实际值
BigDecimal b1 = new BigDecimal(realIncome);
realIncome = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();//保留两位小数
return realIncome;
}
else return -1;
}
public static void main(String args[]){
Vector<Item> itemList=new Vector<Item>();
Item sellItem=new Item();
sellItem.id="1";
sellItem.amount =20;
sellItem.repay =7;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="2";
sellItem.amount =10;
sellItem.repay =3;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="3";
sellItem.amount =15;
sellItem.repay =4;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="4";
sellItem.amount =16;
sellItem.repay =5;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="5";
sellItem.amount =17;
sellItem.repay =5;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="6";
sellItem.amount =25;
sellItem.repay =6;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="7";
sellItem.amount =22;
sellItem.repay =6;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="8";
sellItem.amount =21;
sellItem.repay =7;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="9";
sellItem.amount =20;
sellItem.repay =8;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="10";
sellItem.amount =30;
sellItem.repay =8;
itemList.add(sellItem);
int m = 100; //总重量
int repay=30;//预期贴现
dpTest pack = new dpTest();
pack.backpackmin(m, itemList);
double infact=pack.makePricemin(repay, itemList);
if (infact>0)
{
System.out.println("卖方预期贴现:"+repay+" ,实际贴现:"+infact);
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1)
System.out.println(item.id+":买方预期收益: "+item.repay+" 实际收益:"+item.profit);
}
}
else System.out.println("无匹配项! ");
/*
Vector<Item> itemList=new Vector<Item>();
Item sellItem=new Item();
sellItem.id="1";
sellItem.amount =1000;
sellItem.repay =32;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="2";
sellItem.amount =1000;
sellItem.repay =29;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="3";
sellItem.amount =1000;
sellItem.repay =33;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="4";
sellItem.amount =2000;
sellItem.repay =56;
itemList.add(sellItem);
sellItem=new Item();
sellItem.id="5";
sellItem.amount =2000;
sellItem.repay =60;
itemList.add(sellItem);
int m = 5000; //总量
int repay=150;//预期收益
dpTest pack = new dpTest();
pack.backpackmin(m, itemList);
double infact=pack.makePricemin(repay, itemList);
if (infact>0)
{
System.out.println("卖方预期贴现:"+repay+" ,实际贴现:"+infact);
for (int i=0;i<itemList.size();i++)
{
Item item=itemList.get(i);
if (item.select==1)
System.out.println(item.id+":买方预期收益: "+item.repay+" 实际收益:"+item.profit);
}
}
else System.out.println("无匹配项! ");
*/
/*
int m = 100; //总重量
int n = 10; //数量,
int w[]={20,10,15,16,17,25,22,21,20,30}; //单个重量
int p[]={7,3,4,5,5,6,6,7,8,8}; //值
dpTest pack = new dpTest();
int c[][] = pack.pack(m, n, w, p);
int s[]= pack.printPack(c, w, m,n);
int sumselect=pack.sumSelect(s, p);
System.out.println(sumselect);
pack.calc(sumselect, 30, p);
*/
/* //求最小值
int m = 30; //总重量
int n = 9; //数量,
int w[]={2,5,3,6,4,8,7,9,9}; //单个重量
int p[]={8,15,15,14,15,10,30,10,9}; //值
dpTest pack = new dpTest();
int c[][] = pack.packmin(m, n, w, p);
pack.printPackmin(c, w, m,n);
int m = 30; //总重量
int n = 10; //数量,
//int w[]={3,4,5,6,7,8,9,10,11,12}; //单个重量
//int p[]={4,5,6,9,8,7,6,5,4,3}; //值
int w[]={3,4,5,6,7,8,9,10,11,12}; //单个重量
int p[]={4,5,6,9,8,7,6,5,4,3}; //值
dpTest pack = new dpTest();
int c[][] = pack.packmin(m, n, w, p);
pack.printPackmin(c, w, m,n);
*/
}
}
/*******item类
package dp;
public class Item {
public String id;
public int amount;//额度
public int repay; //预期贴现
public double profit;//实际贴现
public int select;//是否选择标识
public Item()
{
id="";
amount=0;
select=0;
repay=0;
profit=0.0;
}
public Item(String id,int amount,int repay)
{
this.id=id;
this.amount =amount;
this.repay=repay;
}
}