贪心算法

贪心算法

1.Cost_Profit

costs[i]表示i号项目的花费，profits[i]表示i号项目在扣除花费之后还能挣到的利润，k表示你只能串行的最多做K个项目,m表示你初始的资金。

package 贪心算法;

import java.util.Comparator;
import java.util.PriorityQueue;

public class Cost_Profit {
	public static class Node{
		int cost;
		int profit;
		public Node(int c,int p) {
			cost=c;
			profit=p;
		}
	}
	public static class MinheapComparator implements Comparator<Node>{

		@Override
		public int compare(Node o1, Node o2) {
			// TODO 自动生成的方法存根
			return o1.cost-o2.cost;
		}
		
	}
	public static class MaxheapComparator implements Comparator<Node>{

		@Override
		public int compare(Node o1, Node o2) {
			// TODO 自动生成的方法存根
			return o2.profit-o1.profit;
		}
		
	}
	public static int findMaxcost_profit(int k,int w,int[] profit,int[] cost) {
		if(profit==null||cost==null||profit.length<1||cost.length<1) {
			return w;
		}
		Node[] nodes=new Node[profit.length];
		for(int i=0;i<profit.length;i++) {
			nodes[i]=new Node(profit[i],cost[i]);
		}
		PriorityQueue<Node> minPQ=new PriorityQueue<Node>(new MinheapComparator());
		PriorityQueue<Node> maxPQ=new PriorityQueue<Node>(new MaxheapComparator());
		for(int i=0;i<nodes.length;i++) {
			minPQ.add(nodes[i]);
		}
		int time=0;
		while(time<k) {
			while(!minPQ.isEmpty()&&minPQ.peek().cost<w) {
				maxPQ.add(minPQ.poll());
			}
			if(maxPQ.isEmpty()) {
				return w;
			}
			w+=maxPQ.poll().profit;
			time++;
		}
		return w;
	}
}

2.Data_Stream_Median

给一个数据流输出该数据流的中位数。

package 贪心算法;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Data_Stream_Median {
	public static class MyMinComparator implements Comparator<Integer>{

		@Override
		public int compare(Integer o1, Integer o2) {
			// TODO 自动生成的方法存根
			return o1-o2;
		}
	}
	public static class MyMaxComparator implements Comparator<Integer>{

		@Override
		public int compare(Integer o1, Integer o2) {
			// TODO 自动生成的方法存根
			return o2-o1;
		}
		
	}
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		String[] dataStr=sc.nextLine().split(" ");
		int[] datas=new int[dataStr.length];
		for(int i=0;i<datas.length;i++) {
			datas[i]=Integer.valueOf(dataStr[i]);
		}
		PriorityQueue<Integer> minQueue=new PriorityQueue<Integer>(new MyMinComparator());
		PriorityQueue<Integer> maxQueue=new PriorityQueue<Integer>(new MyMaxComparator());
		for(int i=0;i<datas.length;i++) {
			if(maxQueue.isEmpty()) {
				maxQueue.add(datas[i]);
				continue;
			}
			if(maxQueue.peek()>=datas[i]) {
				maxQueue.add(datas[i]);
			}else {
				if(minQueue.isEmpty()) {
					minQueue.add(datas[i]);
					continue;
				}
				if(minQueue.peek()<datas[i]) {
					minQueue.add(datas[i]);
				}else {
					maxQueue.add(datas[i]);
				}
			}
			if(maxQueue.size()==minQueue.size()+2) {
				minQueue.add(maxQueue.poll());
			}
			if(minQueue.size()==maxQueue.size()+2) {
				maxQueue.add(minQueue.poll());
			}
		}
		if((datas.length&1)==0) {    //偶数个，两数相加除以2
			System.out.printf("");
		}else {                      //奇数个
			System.out.println(maxQueue.size()>minQueue.size()?maxQueue.peek():minQueue.peek());
		}
	}
}

3.GoldBarcutting

一块金条切成两半，是需要花费和长度数值一样的铜板的。比如长度为20的金条，不管切成长度多大的两半，都需要花费20个铜板。

package 贪心算法;

import java.util.Comparator;
import java.util.PriorityQueue;

public class GoldBarcutting {
	public static class MinheapComparator implements Comparator<Integer>{

		@Override
		public int compare(Integer o1, Integer o2) {
			// TODO 自动生成的方法存根
			return o1.compareTo(o2);
		}
		
	}
	public static int Less_Money(int[] arr) {
		PriorityQueue<Integer> pQ=new PriorityQueue<Integer>(new MinheapComparator());
		for(int i=0;i<arr.length;i++) {
			pQ.add(arr[i]);
		}
		int sum=0;
		int cur=0;
		while(pQ.size()>1) {
			cur=pQ.poll()+pQ.poll();
			sum+=cur;
			pQ.add(cur);
		}
		return sum;
	}
}

4.LowestString

最低字符串的比较

package 贪心算法;

import java.util.Arrays;
import java.util.Comparator;

public class LowestString {
	public static class MyComparator implements Comparator<String>{

		@Override
		public int compare(String o1, String o2) {
			// TODO 自动生成的方法存根
			return (o1+o2).compareTo(o2+o1);
		}
	}
	public static String lowestString(String[] strs) {
		if(strs==null||strs.length==0) {
			return " ";
		}
		Arrays.sort(strs,new MyComparator());
		String res=" ";
		for(int i=0;i<strs.length;i++) {
			res+=strs[i];
		}
		return res;
	}
}

5.NQueues

N*N的棋盘上，放置N个皇后，要求每一行，每一列，每一对角线上均只能放置一个皇后，求可能的方案及方案数。

package 贪心算法;

public class NQueues {
	public static int num1(int n) {
		if(n<1) {
			return 0;
		}
		int[] record=new int[n];   // record[i] -->i行的皇后，放在的第几列
		return process1(0,record,n);
	}
	//目前来到了第i行，之前摆的皇后都在record里，n整体行数
	//返回合法摆数
	public static int process1(int i,int[] record,int n) {
		if(i==n) {
			return 1;
		}
		int res=0;
		for(int j=0;j<n;j++) {
			if(isValid(record,i,j)) {
				record[i]=j;
				res+=process1(i+1,record,n);
			}
		}
		return res;
	}
	public static boolean isValid(int[] record,int i,int j) {
		for(int k=0;k<i;k++) {
			if(j==record[k]||Math.abs(record[k]-j)==Math.abs(i-k)) {
				return false;
			}
		}
		return true;
	}
	//请不要超过32皇后问题
	public static int num2(int n) {
		if(n<1||n>32) {
			return 0;
		}
		int limit=n==32?-1:(1<<n)-1;    //左移n位表示2的n次方。最终结果为n的二进制表示为n个1
		return process2(limit,0,0,0);
	}
	public static int process2(int limit,int colLim,int leftDiaLim,int rightDiaLim) {
		if(colLim==limit) {
			return 1;
		}
		int pos=0;
		int mostRightOne=0;
		pos=limit&(~(colLim|leftDiaLim|rightDiaLim));
		int res=0;
		while(pos!=0) {
			mostRightOne=pos&(~pos+1);
			pos=pos-mostRightOne;
			res+=process2(limit,colLim|mostRightOne,(leftDiaLim|mostRightOne)<<1,(rightDiaLim|mostRightOne)>>1);
		}
		return res;
	}
	
}

5.ProgramBestArrange

一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲。给你每一个项目开始的时间和结束的时间(给你一个数组，里面是一个个具体的项目)，你来安排宣讲的日程，要求会议室进行的宣讲的场次最多。返回这个最多的宣讲场次。

package 贪心算法;

import java.util.Arrays;
import java.util.Comparator;

public class ProgramBestArrange {
	public static class Program{
		int start;
		int end;
		public Program(int start,int end) {
			this.start=start;
			this.end=end;
		}
	}
	public static class ProgramComparator implements Comparator<Program>{

		@Override
		public int compare(Program arg0, Program arg1) {
			// TODO 自动生成的方法存根
			return arg0.end-arg1.end;
		}
	}
	public static int bestArrange(Program[] programs,int start) {
		Arrays.sort(programs,new ProgramComparator());
		int result=0;
		for(int i=0;i<programs.length;i++) {
			if(start<=programs[i].start) {
				result++;
				start=programs[i].end;
			}
		}
		return result;
	}
}