一个算法,解决自动分配价格,望大家改进

原创 2013年12月03日 21:32:48

需求:

期货上面,要在1236的价格上买100手,要在1237的价格上面买150手(具体不定,可能分的很多)。另一方面:分配到具体的账户上面去买,如a账户要买50手,b账户要买60手,c账户要买140手(这两个购买手数相加是相等的),那么安装账户的顺序分配价格(从小到大),如a账户的50手的价格是1236,b账户的:50手1236价格,10手1237价格,c账户的全部是1237价格。

关键是在所有的变量都是变化的情况下,怎么自动为这些账户分配价格,按照账户的顺序,来从低到高分配价格。
如果上面的不好理解我说过好理解的,商场里面有两种橘子:100斤橘子售价是80元,另外150斤橘子售价是85元。来了n个人,按照顺序买橘子,先来的肯定是买便宜的橘子,如a买了50斤,那么这50斤的价格全是80元,b要买130斤,那么其中50斤价格是80元,剩下的80斤价格是85元,c买了70斤,那么价格肯定是85元,求自动分配价格的算法

刚开始也是毫无头绪,但是经过指点

public class Test938 {	
	public static void main(String[] args) {	
		List<Orange> list = new ArrayList<Orange>();	
		list.add(new Orange(80, 100));		
		list.add(new Orange(90, 200));		
		list.add(new Orange(85, 140));//		将集合中元素按价格从低到高排列		
		Collections.sort(list, new Comparator<Orange>() {	
			@Override		
				public int compare(Orange o1, Orange o2) {	
				return o1.getPrice() - o2.getPrice();	
				}	
                       });		
		sell(50,list);		
		sell(130,list);		
		sell(70,list);		
		sell(300,list);	
	}	/**	
                   * @param count 要卖出的斤数	
                   * @param list  当前的存货	
                   */		
		private static void sell(int count,List<Orange> list){		
			System.out.println("该用户买橘子:"+count+"斤");		
			List<Orange> sellList=new ArrayList<Orange>();				
			List<Orange> delList=new ArrayList<Orange>();		
			Iterator<Orange> it=list.iterator();		
			Orange or=null;		
			int temcount=0;		
			while(it.hasNext()){			
				or=it.next();			
				temcount=or.getTotal();			
				if(temcount>count){				
					or.setTotal(temcount-count);				
					sellList.add(new Orange(or.getPrice(),count));				
					count=0;				
					break;			
					}
				else if(temcount==count){				
					delList.add(or);				
					sellList.add(new Orange(or.getPrice(),count));				
					count=0;				
					break;			
					}
				else {				
					delList.add(or);				
					count-=temcount;				
					sellList.add(new Orange(or.getPrice(),temcount));			
					}		
				}//		更新存货		
				for(Orange o:delList){			
					list.remove(o);		
					}				
				for(Orange o:sellList){			
					System.out.println("   价格:"+o.getPrice()+"<-->"+o.getTotal()+"斤");		
					}				
				if(count>0){			
					System.out.println("   橘子缺货:"+count+"斤");		
					}	
				}
			}
			
			class Orange {	
				private int price;	
				private int total;	
				public Orange(int price, int total) {		
					this.price = price;		
					this.total = total;	
					}	
				public int getPrice()
				{		return price;	}	
				public int getTotal() 
				{		return total;	}	
				public void setTotal(int total)
				{		this.total = total;	}
			}

改进:

 //把总的价格和总的position封装成map,然后把每个需要的position也传入,
   //最后生成的就是封装好的一个list集合,因为这个账户可能有不同的价格和position。
    private static List<Map<Double,Integer>> buy(int position,Map<Double,Integer> map)
    {   //Map<Double,Integer> localMap=map;//把传过来的map转化为本地的map。
        List<Map<Double,Integer>> end=new ArrayList<Map<Double, Integer>>();//返回的list集合,就是计算后的list集合,里面是map
        List<Double> delKey=new ArrayList();//每个轮回需要删除的map的key
        for (Map.Entry<Double, Integer> m : map.entrySet()) {
            
            int sumPosition=m.getValue();
            
            if(position<sumPosition)
            {   
                Map<Double,Integer> returnMap=new LinkedHashMap();
                returnMap.put(m.getKey(), position);
                end.add(returnMap);
                m.setValue(sumPosition-position);
                break;
            }else if(position==sumPosition)
            { Map<Double,Integer> returnMap=new LinkedHashMap();
                returnMap.put(m.getKey(), position);
                end.add(returnMap);
                delKey.add(m.getKey());
              
                break;
            }
            else{
                
                 Map<Double,Integer> returnMap=new LinkedHashMap();
                returnMap.put(m.getKey(), sumPosition);
                end.add(returnMap);
                delKey.add(m.getKey());
               
                position-=sumPosition;
                  }
            }
            //清理货存
            for(Double del:delKey)
            {
               
             map.remove(del);
            }
//          for(Map<Double,Integer> endmap:end)
//          {
//              for(Map.Entry<Double,Integer> entry:endmap.entrySet())
//              {
//                  System.out.println("价格"+entry.getKey()+"...."+"仓位"+entry.getValue());
//              }
//          }
      
        return end;
    }

上面的算法并不算好,就是对于每个分配好的账户都封装到一个map里面(一个map只装一个键值对,这样觉得浪费),然后再把这些map封装到list的集合中。

大家谁有好的算法,欢迎指点。




BP算法改进

BP算法的问题 权值初始化 用于权值 初始化 的一个普遍方法是设置为:区间[−0.5N,0.5N]\left [ \frac{-0.5}{N} , \frac{0.5}{N}\right ]内,均...
  • chenjianbo88
  • chenjianbo88
  • 2016年08月30日 22:27
  • 2419

任务分配问题(匈牙利算法)

全文搬运自  http://www.cnblogs.com/dwdxdy/p/3261742.html  (仅作收藏之用) 【算法题】任务分配问题---匈牙利算法 一、问题描述...
  • qq_25945437
  • qq_25945437
  • 2017年04月27日 00:21
  • 680

KNN及其改进算法的python实现

一、 马氏距离 我们熟悉的欧氏距离虽然很有用,但也有明显的缺点。它将样品的不同属性(即各指标或各变量)之间的差别等同看待,这一点有时不能满足实际要求。例如,在教育研究中,经常遇到对人的分析和判别,个...
  • HUSTLX
  • HUSTLX
  • 2016年03月10日 21:07
  • 1724

通用资源分配算法

现实生活中很多情景下都存在资源紧缺的情况,比如XXX大学今年就招生N个学生,那该如何入分配这几个名额呢?鉴于这种情景在现实生活中太多,而且很多情况下合理分配这些资源需要投入大量人力物力去分析和研究。我...
  • u012308971
  • u012308971
  • 2017年08月13日 19:21
  • 604

周志华《机器学习》课后习题解答系列(六):Ch5.6 - BP算法改进

引入“动量项+自适应学习率”来进行BP算法改进,采用iris数据集进行了改进前后对比实验。...
  • Snoopy_Yuan
  • Snoopy_Yuan
  • 2017年04月27日 11:06
  • 1153

Apriori算法改进--FP-Tree(FP-Growth)算法

FP-Tree算法 FPTree算法:在不生成候选项的情况下,完成Apriori算法的功能。 FPTree算法的基本数据结构,包含一个一棵FP树和一个项头表,每个项通过一个结点链指向它在树...
  • yimingsilence
  • yimingsilence
  • 2016年11月15日 20:14
  • 1827

堆排序算法的改进

堆排序算法的时间复杂度为O(nlogn),一般采用上滤建堆,如果考虑用下滤建堆,不仅可以精简代码,而且时间也会更快。 //堆排序算法的改进 void siftdown(int *v, int l, i...
  • moses1213
  • moses1213
  • 2016年01月26日 21:29
  • 429

自动分配座位

问题描述   请实现一个铁路购票系统的简单座位分配算法,来处理一节车厢的座位分配。   假设一节车厢有20排、每一排5个座位。为方便起见,我们用1到100来给所有的座位编号,第一排是1到5号,第二排是...
  • u014800094
  • u014800094
  • 2016年11月07日 15:45
  • 321

TF-IDF 算法改进

概念 : TF-IDF(term frequency–inverse document frequency)是一种用于资讯检索与资讯探勘的常用加权技术。TF-IDF是一种统计方法,用以评估一字词对于一...
  • kl28978113
  • kl28978113
  • 2016年10月24日 15:34
  • 1192

Prim算法 (改进)

前几篇文章,发的都是Prim算法差不多O(n^3)的时间复杂度,其实标准的Prim算法,时间复杂度是O(n^2),所以需要改进,Prim算法就是U集合的增大和V-U集合的减少,总共要进行n-1次地把点...
  • John_Denver
  • John_Denver
  • 2008年11月21日 22:28
  • 1375
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:一个算法,解决自动分配价格,望大家改进
举报原因:
原因补充:

(最多只允许输入30个字)