修理桌子

大体思路是把先把输入的腿长映射到一个106维的腿长数目数组，数组中的值为对应腿长的的数目。然后从后往前遍历
没碰到一个腿长，将比他高的腿长砍掉，同时计算还需要砍多少桌腿，对剩余的桌腿排序砍掉对应部分，然后计算最小值。
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int main()
{
    int n;
    while(cin>>n)
    {
        vector<int >l,d,d_cut;
        int a[106]={0};
        int li,di;
        for(int i=0;i<n;i++)
        {
            cin>>li;
            l.push_back(li);
            a[li]++;
        }
        int minCost=0;
        for(int i=0;i<n;i++)
        {
            cin>>di;
            d.push_back(di);
            minCost+=di;
        }
        for(int i=105;i>0;i--)
        {
            int cost=0; 
            d_cut.clear();
            if(a[i])
            {
                int cutLegNum=l.size()-a[i];
                for(int j=i+1;j<=105;j++)
                {
                    cutLegNum-=a[j];
                }
                cutLegNum-=(a[i]-1);
                for(int k=0;k<n;k++)
                {
                    if(l[k]<i)
                        d_cut.push_back(d[k]);
                    if(l[k]>i)
                        cost+=d[k];
                }
                if(cutLegNum>0)
                {
                    sort(d_cut.begin(),d_cut.end()); 
		    for (int k = 0; k <cutLegNum; k++)
                        cost+=d_cut[k];
                    if(cost<minCost)
                        minCost=cost;
                }      
            }
        }
        cout<<minCost<<endl;
    }
    return 0;  
}

#--coding:utf-8--
class Deskleg(object):
    def __init__(self,li,di):
        self.li,self.di=li,di
 
#根据di、li由小到大排序的比较函数
def sort_di(x,y):
    return x.di-y.di
def sort_li(x,y):
    return x.li-y.li
#主函数
def Solution():
    nums=int(raw_input())
    _li=raw_input().split()
    _di=raw_input().split()
    ans=[]#存储可能出现的所有代价
    list_a=[]#存储所有桌腿数据
    for i in range(nums):
        list_a.append(Deskleg(int(_li[i]),int(_di[i])))
    list_a.sort(sort_li)
    list_b=[]#二维列表，li、di由小到大排列
    count=1
    temp=[list_a[0]]
    while count<nums:
        if list_a[count].li==list_a[count-1].li:
            temp.append(list_a[count])
        else:
            list_b.append(temp)
            temp=[list_a[count]]
        count+=1
    list_b.append(temp)
    for i in list_b:
        i.sort(sort_di)
    #开始求解
    for i in range(len(list_b)):
        a_ans=0
        l1=len(list_b[i])#最长桌腿数
        l2=0#存储比最长桌腿短的桌腿数
        for j in range(i+1,len(list_b)):
            for k in list_b[j]:
                a_ans+=k.di
        temp_1=[]
        if i>0:
            for j in range(0,i):
                for k in list_b[j]:
                    temp_1.append(k)
            l2=len(temp_1)
            temp_1.sort(sort_di)
        if l2>=l1:
            for m in range(l2-l1+1):
                a_ans+=temp_1[m].di
        ans.append(a_ans)
    return min(ans)
print Solution()

//VS调试中正确，放在网页里不对
#include <iostream>
#include <map>
#include <vector>
#include <queue>
using namespace std;
struct leg
{
	int count = 0;
	int total = 0;
	vector<int> costs;
};
map<int, leg> table;
typedef map<int, leg>::iterator miterator;

int calculate(miterator it, int n, int cost);
int main()
{
	int n, temp;
	//进行数据输入
	cin >> n;
	vector<pair<int, int> > legs(n, pair<int, int>(0, 0));
	for (int i = 0; i<n; i++)
	{
		cin >> temp;
		legs[i].first = temp;
	}
	for (int i = 0; i<n; i++)
	{
		cin >> temp;
		legs[i].second = temp;
	}
	//进行数据整合
	for (int i = 0; i<legs.size(); i++)
	{
		int len = legs[i].first;
		table[len].count++;
		table[len].total += legs[i].second;
		table[len].costs.push_back(legs[i].second);
	}
	//进行数据处理
	miterator iter = --table.end();
	int result = calculate(iter, n, 0);
	cout << result << endl;
	return 0;
}
//建立计算函数
int calculate(miterator it, int n, int cost)
{
	if (it->second.count * 2>n)
		return cost;
	//递归算法
	//去掉当前最大长度的桌子
	int result1 = calculate(--it, n - it->second.count, cost + it->second.total);
	//保留当前最大长度桌子
	++it;
	int result2 = cost;
	int k = n - 2 * it->second.count + 1;
	priority_queue<int> dearr;
	for (miterator p = table.begin(); p != it; p++)
		for (int i = 0; i<p->second.costs.size(); i++)
			if (dearr.size()<k)
				dearr.push(p->second.costs[i]);
			else if (dearr.top()>p->second.costs[i])
			{
				dearr.pop();
				dearr.push(p->second.costs[i]);
			}
	while (dearr.size() != 0)
	{
		result2 += dearr.top();
		dearr.pop();
	}
	int result = result1<result2 ? result1 : result2;
	return result;
}

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] li = new int[n];
        for(int i=0; i<n; i++){
            li[i] = scanner.nextInt();
        }
        int[] di = new int[n];
        for(int i=0; i<n; i++){
            di[i] = scanner.nextInt();
        }

        //按桌腿长度从大到小排序
        for(int i=0; i<n-1; i++){
            int index = i;
            for(int j=i+1; j<n; j++){
                if(li[j]>li[index]){
                    index = j;
                }
            }
            if(index!=i){
                int temp = li[i];
                li[i] = li[index];
                li[index] = temp;
                temp = di[i];
                di[i] = di[index];
                di[index] = temp;
            }
        }

        int result = getMin(li, di, 0, n);
        System.out.println(result);
    }

    //求最优解
    public static int getMin(int[] li, int[] di, int start, int n){

        int maxNum = 1;
        int count = di[start];
        for(int i=start+1; i<n; i++){
            if(li[i]==li[start]){
                maxNum++;
                count += di[i];
            }else{
                break;
            }
        }

        if(maxNum*2>n-start){
            return 0;
        }
        else{
            //不保留当前最长桌腿
            int a = getMin(li, di, start+maxNum, n) + count;
            //保留当前最长桌腿
            int b = getCount(li, di, start+maxNum, maxNum, n);
            return a<b?a:b;
        }
    }

    //保留最长桌腿，砍去其他代价和最小的部分桌腿s
    private static int getCount(int[] li, int[] di, int start, int maxNum, int n) {
        int num = n-start-maxNum;
        if(num<0){
            return 0;
        }else{
            int[] arr = new int[n-start];
            int length = arr.length;
            for(int i=0; i<arr.length; i++){
                arr[i]=di[start+i];
            }
            int count = 0;
            int x = 0;
            while(num>=0){
                int index=x;
                for(int i=x; i<length; i++){
                    if(arr[i]<arr[index]){
                        index=i;
                    }
                }
                int temp = arr[index];
                arr[index] = arr[x];
                arr[x] = temp;
                count += arr[x];
                x++;
                num--;
            }
            return count;
        }
    }
}


	

#include <iostream>
#include <cstring>
#include <stdio.h>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <algorithm>
#include <set>
#define MM(a,b) memset(a,b,sizeof(a))
#define rf(a) scanf("%lf",&a)
#define ri(a) scanf("%d",&a)
#define PF printf
#define PB push_back
#define SC scanf
#define CT continue
typedef long long ll;
typedef unsigned long long ULL;
const double eps = 1e-14;
const int inf = 0x3f3f3f3f;
const int N=1e2+10;
const double pi=acos(-1);
using namespace std;

struct node{
   int l,d;
}ne[N];

bool cmpd(const node&a,const node &b)
{
   return a.d<b.d;
}


int main()
{
    int n;
    while(~ri(n)){
        for(int i=1;i<=n;i++)  ri(ne[i].l);
        for(int i=1;i<=n;i++)  ri(ne[i].d);
        int ans=inf;
        sort(ne+1,ne+n+1,cmpd);
        for(int i=1;i<=n;i++){
            int tmp=0,cut=0,equ=0;
            for(int j=1;j<=n;j++)
                if(ne[j].l>ne[i].l) tmp+=ne[j].d,cut++;
                else if(ne[j].l==ne[i].l) equ++;
            for(int j=1;j<=n&&equ<=(n-cut)/2;j++)
                if(ne[j].l<ne[i].l){
                cut++,tmp+=ne[j].d;
            }
            ans=min(ans,tmp);
        }
        PF("%d\n",ans);
    }
    return 0;
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            int[] ln = new int[n];
            int[] dn = new int[n];
            for (int i = 0; i < n; i++) {
                ln[i] = in.nextInt();
            }
            for (int i = 0; i < n; i++) {
                dn[i] = in.nextInt();
            }
            int min = count(ln, dn);
            System.out.println(min);
        }
    }
    
    private static int count(int[] ln, int[] dn) {
        List<Node> list = new ArrayList<>();
        for (int i = 0; i < ln.length; i++) {
            list.add(new Node(ln[i], dn[i]));
        }

        return count(list);
    }

    private static int count(List<Node> list) {
        List<Node> max = new ArrayList<>();
        if (list == null || list.size() == 0 || isStable(list, max)) {
            return 0;
        }

        Collections.sort(list, new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                return o1.cost < o2.cost ? 1 : -1;
            }
        });
        int cost1 = 0;
        for (int i = max.size() - 1; i < list.size(); i++) {
            cost1 += list.get(i).cost;
        }
        int cost2 = 0;
        for (int i = 0; i < max.size(); i++) {
            cost2 += max.get(i).cost;
        }

        return Math.min(cost1, cost2 + count(list));
    }

    /**
     * 判断桌子当前是否稳定
     *
     * @param list
     * @return
     */
    private static boolean isStable(List<Node> list, List<Node> max) {
        int maxLen = 0;
        for (int i = 0; i < list.size(); i++) {
            maxLen = maxLen < list.get(i).length ? list.get(i).length : maxLen;
        }
        int m = 0;
        max.clear();
        for (int i = 0; i < list.size(); i++) {
            if (maxLen == list.get(i).length) {
                m++;
                max.add(list.get(i));
            }
        }
        for (int i = 0; i < max.size(); i++) {
            list.remove(max.get(i));
        }

        return m * 2 > (list.size() + max.size());
    }

    static class Node {
        public int length;
        public int cost;

        public Node(int length, int cost) {
            this.length = length;
            this.cost = cost;
        }
    }
}

#include <iostream>
#include <vector>
#include <unordered_map>
#include <climits>
#include <algorithm>
using namespace std;

int main(int argc, char *argv[])
{
    int n;
    while (cin >> n) {
        vector<int> len, val;
        // 表示某一个长度的桌腿出现的次数
        unordered_map<int, int> ump;
        len .resize(n), val.resize(n);
        for (int i = 0; i < n; ++i) {
            cin >> len[i];
            ++ump[len[i]];
        }
        for (int i = 0; i < n; ++i) {
            cin >> val[i];
        }
        // input finished
        int ret = INT_MAX;
        for (auto &ele:ump) {
            // 以var为最终的桌腿的标准
            int var = ele.first;
            // 表示代价
            int cost = 0;
            vector<pair<int, int> > mp;
            for (int i = 0; i < n; ++i) {
                // 凡是比var大的桌腿都割掉,比它小的加入一个集合
                if (len[i] > var) {
                    cost += val[i];//割掉
                } else if (len[i] < var) {
                    // 比var小的桌腿加入mp集合
                    mp.push_back({val[i], i});
                }
            }
            // 将集合里面的元素按照割掉的代价排序
            sort(mp.begin(), mp.end(), [](const pair<int,int> &p1, const pair<int, int> &p2)
            { return p1.first < p2.first;});
            // 长度为 var 总共的桌腿条数
            int sz_var = ump[var];
            // 比var小的桌腿条数
            int sz_mp = mp.size();
            // 割掉小的，留大的
            if (sz_mp < sz_var) {//无需割掉
                ret = min(ret, cost);
            } else {
                // 需要割掉的条数
                int cnt = sz_mp - sz_var + 1;
                // 肯定是mp割前面的
                for (auto it = mp.begin(); it != next(mp.begin(), cnt); ++it) {
                    cost += it->first;
                }
                ret = min(ret, cost);
            }
        }//for
        cout << ret << endl;
    }//while
    return 0;
}

	# coding=utf-8



	"""



	1. 比当前长度大的都要去除



	2. 根据剩余中是否满足最大个数大于一般条件处理小于当前长度的值



	"""



	def solution(l_lst, c_lst, n):  # 输入 长度lst 和 代价lst



	    all_len = set(l_lst)



	    len_cast = zip(c_lst, l_lst)



	    len_cast.sort()



	    ret = []



	    foreach_len in all_len:



	        tmp_mx = []



	        tmp_mi = []



	        tmp_count = l_lst.count(each_len)



	        fore in len_cast:



	            ifeach_len < e[1]:



	                tmp_mx.append(e[0])



	            elif each_len > e[1]:



	                tmp_mi.append(e[0])



	        iflen(tmp_mx) > n - 2*tmp_count:



	            tmp_sum = sum(tmp_mx)



	        else:



	            tmp_mi.sort()



	            tmp_sum = sum(tmp_mi[:1+n-2*tmp_count-len(tmp_mx)]) + sum(tmp_mx)



	        ret.append(tmp_sum)



	    returnmin(ret)



	 



	importsys



	 



	try:



	    whileTrue:



	        line = sys.stdin.readline().strip()



	        ifnot line:



	            break



	        n = int(line)



	        line_2 = sys.stdin.readline().strip().split()



	        line_3 = sys.stdin.readline().strip().split()



	        line_2 = map(int, line_2)



	        line_3 = map(int, line_3)



	        # len_cast = zip(line_2, line_3)



	        print solution(line_2, line_3, n)



	except:



	    pass

	
	

		
		

			
			

				
				

					
					

						
						

							
							

								#include<iostream>
							

							

								#include<vector>
							

							

								#include<map>
							

							

								#include<algorithm>
							

							

								using namespace std;
							

							

								 
							

							

								intcal(map<int,vector<int>> &lc){
							

							

								    map<int,vector<int>>::iterator itr=lc.begin();
							

							

								    intsize=0;//所有数据的个数
							

							

								    intmaxlen=0;//最长腿
							

							

								    while(itr!=lc.end()){
							

							

								        if(maxlen<itr->first){
							

							

								            maxlen=itr->first;
							

							

								        }
							

							

								        size+=(itr->second).size();
							

							

								        itr++;
							

							

								    }
							

							

								    intcurrsize=lc[maxlen].size();
							

							

								    if(currsize>size/2)//如果最长退满足约束条件
							

							

								        return0;
							

							

								     
							

							

								    vector<int> tmp;//存储所有短腿的代价值
							

							

								    itr=lc.begin();
							

							

								    while(itr!=lc.end()){
							

							

								        if(itr->first!=maxlen){
							

							

								            tmp.insert(tmp.end(),itr->second.begin(),itr->second.end());
							

							

								        }       
							

							

								        itr++;
							

							

								    }
							

							

								    sort(tmp.begin(),tmp.end());//按代价值升序排列
							

							

								    intc2=0;//保留最长腿的代价
							

							

								    while(!tmp.empty()&&currsize<=(currsize+tmp.size())/2){
							

							

								        c2+=tmp.front();
							

							

								        tmp.erase(tmp.begin());
							

							

								    }
							

							

								    intc1=0;//去掉最长退的代价
							

							

								    for(inti=0;i<currsize;i++){
							

							

								        c1+=lc[maxlen][i];
							

							

								    }
							

							

								    lc.erase(maxlen);
							

							

								    c1+=cal(lc);
							

							

								    returnc1<c2?c1:c2;
							

							

								}
							

							

								intmain(){
							

							

								    intn;
							

							

								    vector<int> L;
							

							

								    vector<int> C;
							

							

								     
							

							

								    intl,c;
							

							

								    while(cin>>n){
							

							

								        L.clear();
							

							

								        C.clear();
							

							

								        for(inti=0;i<n;i++){
							

							

								            cin>>l;
							

							

								            L.push_back(l);
							

							

								        }
							

							

								        for(inti=0;i<n;i++){
							

							

								            cin>>c;
							

							

								            C.push_back(c);
							

							

								        }
							

							

								        map<int,vector<int>> lc;
							

							

								         //构造map
							

							

								        for(inti=0;i<n;i++){
							

							

								            l=L[i];
							

							

								            if(lc.find(l)==lc.end()){
							

							

								                vector<int> v;
							

							

								                v.push_back(C[i]);
							

							

								                lc.insert(make_pair(l,v));
							

							

								            }
							

							

								            else{
							

							

								                lc[l].push_back(C[i]);
							

							

								            }
							

							

								        }
							

							

								        cout<<cal(lc)<<endl;
							

							

								    }
							

							

								    return0;
							

							

								}
							

							

								
							

							

								在所有的数值输入之后，设计一个map<int,vector<int>>，是一个长度值对应的所有的代价值；
							

							

								如果在当前状态下，最长的腿占比例>1/2,代价为0；
							

							

								否则，在计算代价时，需要分两种情况考虑：（1）保留最长的腿，然后将短腿中代价之最小的一部分删除，直至长腿占比例>1/2；
							

							

								（2）删除最长腿，代价+递归调用；
							

							

								然后最终的结果是（1）（2）两种情况的最小值；
							

							

								
							

						

					

				

			

		

	




	
	

		添加笔记
		

			
		

	

#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<climits>
using namespace std;

bool compare(pair<int,int> a,pair<int,int> b){
    return a.second<b.second;
}


int main(){
	int n;
    vector<int> res;
    while(cin>>n){
        map<int,int> m;
        vector<pair<int,int> > con;
        vector<int> length(n);
        for(int i=0;i<n;i++){
            cin>>length[i];
		}
        for(int i=0;i<n;i++){
            int tmp;
            cin>>tmp;
            con.push_back(make_pair(length[i],tmp));
            if(m.find(length[i])!=m.end()){
                m[length[i]]++;
			}else{
                m[length[i]]=1;
			}
		}
        sort(con.begin(),con.end(),compare);
        
        int minValue = INT_MAX;
        int last = 0;
        for(map<int,int>::iterator it = m.begin();it!=m.end();it++){
            int tmp = it->second;
            int count = tmp-1;
			if(count<last){
                count = last-count;
			}else{
                count=0;
			}
            int value = 0;
            for(int i=0;i<n;i++){
                if(con[i].first>it->first){
                    value +=con[i].second;
				}
                if(con[i].first<it->first&&count){
                    value+=con[i].second;
                    count--;
				}
				
			}
			last+=it->second;
            minValue = min(minValue,value);
		}
        cout<<minValue<<endl;
	}
    return 0;
}

	#include <iostream>



	#include <string>



	#include <vector>



	#include <map>



	#include <algorithm>



	using namespace std;



	 



	#include <limits.h>



	 



	intmain()



	{



	    intn;



	    cin >> n;



	    vector<int> l(n);



	    vector<int> d(n);



	    intflag[106] = {0};



	    for(inti=0; i<n; i++)



	        cin >> l[i];



	    for(inti=0; i<n; i++)



	        cin >> d[i];



	    intcost = INT_MAX;



	    for(inti=0; i<n; i++)



	    {



	        if(flag[l[i]])



	            continue;



	        intmaxl = l[i];



	        flag[106] = 1;



	        vector<int> value;



	        inteq_nr = 0;



	        inttmp = 0;



	        for(intj=0; j<n; j++)



	        {



	            if(l[j] == maxl)



	                eq_nr ++;



	            elseif(l[j] < maxl)



	                value.push_back(d[j]);



	            elseif(l[j] > maxl)



	                tmp += d[j];



	        }



	        if(eq_nr > value.size())



	            cost = cost > tmp ? tmp : cost;



	        else



	        {



	            sort(value.begin(), value.end());



	            for(intk=0; k<value.size()-eq_nr+1; k++)



	                tmp += value[k];



	            cost = cost > tmp ? tmp : cost;



	        }



	    }



	    cout << cost << endl;



	    return0;



	}

	#include<iostream>



	#include<vector>



	#include<algorithm>



	using namespace std;



	  



	intmain()



	{



	    intn;



	    while(cin>>n)



	    {



	        vector<int>l,d,d_cut;



	        inta[106]={0};



	        intli,di;



	        for(inti=0;i<n;i++)



	        {



	            cin>>li;



	            l.push_back(li);



	            a[li]++;



	        }



	        intminCost=0;



	        for(inti=0;i<n;i++)



	        {



	            cin>>di;



	            d.push_back(di);



	            minCost+=di;



	        }



	        for(inti=105;i>0;i--)



	        {



	            intcost=0;



	            d_cut.clear();



	            if(a[i])



	            {



	                intcutLegNum=l.size()-a[i];



	                for(intj=i+1;j<=105;j++)



	                {



	                    cutLegNum-=a[j];



	                }



	                cutLegNum-=(a[i]-1);



	                for(intk=0;k<n;k++)



	                {



	                    if(l[k]<i)



	                        d_cut.push_back(d[k]);



	                    if(l[k]>i)



	                        cost+=d[k];



	                }



	                if(cutLegNum>0)



	                {



	                    sort(d_cut.begin(),d_cut.end());



	            for(intk = 0; k <cutLegNum; k++)



	                        cost+=d_cut[k];



	                    if(cost<minCost)



	                        minCost=cost;



	                }    



	            }



	        }



	        cout<<minCost<<endl;



	    }



	    return0;



	}

 #include <iostream>

using namespace std;

// 升序排列arr, temparr做同样的位置改变
void quick_sort(int arr[], int low, int high, int temparr[]) {
	if (low < high) {
		int key = arr[low];
		int key_t = temparr[low];
		int i = low, j = high;
		while (i < j) {
			while (i < j && arr[j] >= key)	--j;
			arr[i] = arr[j];
			temparr[i] = temparr[j];
			while (i < j && arr[i] <= key)	++i;
			arr[j] = arr[i];
			temparr[j] = temparr[i];
		}

		arr[i] = key;
		temparr[i] = key_t;
		quick_sort(arr, low, i - 1, temparr);
		quick_sort(arr, i + 1, high, temparr);
	}
}

// 在已排好序的arr中，按照3temparr中的值进行二级排序
void resort(int arr[], int len, int temparr[], int legIndex[]) {
	int t = arr[0];
	int low = 0, high = 0;
	legIndex[0] = 0;
	for (int i = 1;i < len;++i) {
		if (t == arr[i]) {
			++high;
			legIndex[i] = low;
		}
		else {
			if (low != high) {
				quick_sort(temparr, low, high, arr);
			}
			t = arr[i];
			low = high = i;
			legIndex[i] = low;
		}

		if(i == len - 1 && low != high)
			quick_sort(temparr, low, high, arr);
	}
}

void getResult(int lLen[], int lVal[], int lIndex[], int n, int &rslt) {
	int t = lLen[0], cnt = 0;
	int rslt_t = 0;
	for (int i = 0;i < n;++i) {
		if (t == lLen[i]) {
			++cnt;
		}
		else {
			for (int j = i;j < n;++j)
				rslt_t += lVal[j];			//砍掉大于目标腿长的
			if ((0 != lIndex[i - 1]) && (cnt <= i / 2)) {
				int *arr = new int[lIndex[i - 1]];
				for (int j = 0;j < lIndex[i - 1];++j)
					arr[j] = lVal[j];
				quick_sort(arr, 0, lIndex[i - 1] - 1, arr);

				for (int k = 0;k < lIndex[i - 1] - cnt + 1;++k)
					rslt_t += arr[k];

				delete[] arr;
			}

			if (0 == lIndex[i - 1])
				rslt = rslt_t;
			if (rslt_t < rslt)
				rslt = rslt_t;
			rslt_t = 0;
			t = lLen[i];
			cnt = 1;
		}

		if (i == n - 1) {
			if ((0 != lIndex[i - 1]) && (cnt <= i / 2)) {
				int *arr = new int[lIndex[i - 1]];
				for (int j = 0;j < lIndex[i - 1];++j)
					arr[j] = lVal[j];
				quick_sort(arr, 0, lIndex[i - 1] - 1, arr);

				for (int k = 0;k < lIndex[i - 1] - cnt + 1;++k)
					rslt_t += arr[k];

				delete[] arr;
			}

			if (0 == lIndex[i - 1])
				rslt = rslt_t;
			if (rslt_t < rslt)
				rslt = rslt_t;
		}
	}
}

int main()
{
	int n = 0;
	int *legLen = NULL;
	int *legVal = NULL;
	int *legIndex = NULL;	//每种桌腿的首个位置
	int sum_val_min = 0;

	while (cin >> n) {
		legLen = new int[n];
		legVal = new int[n];
		legIndex = new int[n];

		for (int i = 0;i < n;++i)
			cin >> legLen[i];
		for (int i = 0;i < n;++i)
			cin >> legVal[i];

		quick_sort(legLen, 0, n - 1, legVal);
		resort(legLen, n, legVal, legIndex);

		getResult(legLen, legVal, legIndex, n, sum_val_min);

		cout << sum_val_min << endl;

		/*for (int i = 0;i < n;++i)
			cout << legLen[i] << "  ";
		cout << endl;
		for (int i = 0;i < n;++i)
			cout << legVal[i] << "  ";
		cout << endl;
		for (int i = 0;i < n;++i)
			cout << legIndex[i] << "  ";
		cout << endl;*/

		delete[] legLen;
		delete[] legVal;
		delete[] legIndex;
	}

	return 0;
}
代码有点长，有两个排序辅助函数，两次排序主要是对腿长数组和代价数组进行排序，按照腿长升

序，相同腿长按照代价再次进行升序排列。

排序之后就好计算了，依次计算保留某长度的腿需要消耗的最小代价，首先比目标长度大的毫无疑问

全部砍掉，然后判断是否需要砍掉部分小于该长度的腿，保证目标腿长的数量超过一半。对小于目标

腿长的进行再次排序，确定需要砍掉的数量后，直接从开始砍就行。

写得非常复杂。。。将就看吧