个扔入海中,拿走了一份。第二只猴子把剩下的桃子又平均分成五份,又多了一个,它同样把多的一个扔入海中
,拿走了一份,第三、第四、第五只猴子都是这样做的,问海滩上原来最少有多少个桃子?
分析:假设桃子的数量为total,则每次猴子拿走后桃子的数量为total=total-(total/5+1),当每只猴子拿桃子的时候恰好桃子数量对5求余数刚好为1且桃子数量大于5的时候,累计得到的桃子的数量达到最小,本人给的思路是穷举法,代码如下:
public int getTaoZi(){
//假设桃子的数量
int result = 6;
//用于存放当前桃子的数量
int temp = 0;
while(true){
//每次循环记录下当前桃子的数量
temp = result;
//对每只猴子拿完桃子进行分析
for(int i=0;i<5;i++){
//判断剩下的桃子是否还足够可以分配给其它猴子
if((temp>5&&(temp%5==1))){
//计算每只猴子拿完桃子后所剩下的桃子数量
temp -= ((temp/5)+1);
//当5只猴子全部拿完后,返回桃子的最少数量
if(i==4){
return result;
}
}else{
break;
}
}
result++;
}
}
最大整数
设有n个正整数,将它们连接成一排,组成一个最大的多位整数。
例如:n=3时,3个整数13,312,343,连成的最大整数为34331213。
又如:n=4时,4个整数7,13,4,246,连成的最大整数为7424613。
输入:n
N个数
输出:连成的多位数
算法分析:此题很容易想到使用贪心法,在考试时有很多同学把整数按从大到小的顺序连接起来,测试题目的例子也都符合,但最后测试的结果却不全对。按这种标准,我们很容易找到反例:12,121应该组成12121而非12112,那么是不是相互包含的时候就从小到大呢?也不一定,如12,123就是12312而非12123,这种情况就有很多种了。是不是此题不能用贪心法呢?
其实此题可以用贪心法来求解,只是刚才的标准不对,正确的标准是:先把整数转换成字符串,然后在比较a+b和b+a,如果a+b>=b+a,就把a排在b的前面,反之则把a排在b的后面。
java源程序:
public static void main(String[] args){
String str = "";
ArrayList<String> array = new ArrayList<String>();
Scanner in = new Scanner(System.in);
System.out.println("Please input the number of data:");
int n = in.nextInt();
System.out.println("Please input the data:");
while (n-- > 0) {
array.add(in.next());
}
for(int i = 0; i < array.size(); i ++)
for(int j = i + 1; j < array.size(); j ++){
if((array.get(i) + array.get(j)).compareTo(array.get(j) + array.get(i)) < 0){
String temp = array.get(i);
array.set(i, array.get(j));
array.set(j, temp);
}
}
for(int i = 0; i < array.size(); i ++){
str += array.get(i);
}
System.out.println("str=:"+str);
}
}
题目描述
输入描述:
二叉树的镜像定义:源二叉树 8 / \ 6 10 / \ / \ 5 7 9 11 镜像二叉树 8 / \ 10 6 / \ / \ 11 9 7 5
解决思路:本题采用递归解决,将每一个左子节点和右子节点进行交换
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public void Mirror(TreeNode root) {
TreeNode currentNode = root;
if(root==null){
return;
}
TreeNode tempNode = currentNode.left;
currentNode.left = currentNode.right;
currentNode.right = tempNode;
Mirror(currentNode.left);
Mirror(currentNode.right);
}
}
题目描述
输入:输入一行字符,计算每个字符的个数
输出:例如:‘1234123’ ;输出:‘1’:2,‘2’:2,‘3’:2,‘4’:1
public static void quickSort(char[] data,int left,int right){
int i,j;
char base,temp;
if(left>right){
return;
}
i = left;
j = right;
base = data[left];
while(i!=j){
while(data[j]>=base&&i<j){
j--;
}
while(data[i]<=base&&i<j){
i++;
}
if(i<j){
temp = data[i];
data[i]=data[j];
data[j]=temp;
}
}
data[left]=data[i];
data[i]=base;
quickSort(data,left,i-1);
quickSort(data,i+1,right);
}
public static void total(char[] data){
int start = 0;
int count = 0;
boolean isFinish =false;
while(start<data.length&&!isFinish){
char temp = data[start];
for(int i=start;i<data.length;i++){
if(start==data.length-1){
isFinish = true ;
}
if(data[start]==data[i]){
count++;
}else{
start = i;
break;
}
}
System.out.print("'"+temp+"'"+":"+count+" ");
count=0;
}
}
public static void main(String[] args) {
String str = "1234123";
char[] data = str.toCharArray();
quickSort(data, 0, data.length-1);
total(data);
}
题目描述
把字符串:“aaa23nadfs343”,数字放前面字母放后面
public static void divide(String str){
char[] data = str.toCharArray();
for(int i=0;i<data.length;i++){
if(data[i]>='0'&&data[i]<='9'){
int k = i;
char temp = data[i];
while(k>0&&!(data[k-1]>='0'&&data[k-1]<='9')){
data[k]=data[k-1];
k--;
}
data[k]=temp;
}
}
System.out.println(new String(data,0,data.length));
}
题目描述
分析:本题解决思路是利用递归来进行解答,两个链表首先找出头结点较小的链表,并进行交换,再遍历头结点较小的链表,直到找到比另一个链表中头结点要大的节点,找到后,将遍历后的当前节点与另一个链表的头结点进行连接,依照此规律进行递归,递归完成后,返回较小链表的头结点,即可满足要求。
代码如下:
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1==null){
return list2;
}
if(list2==null){
return list1;
}
return getResult(list1,list1,list2);
}
public ListNode getResult(ListNode list1,ListNode leftNode,ListNode rightNode){
if(leftNode.val>rightNode.val){
ListNode tempNode = leftNode;
leftNode = rightNode;
rightNode = tempNode;
}
//遍历list1链表,直到找到list1链表中比list2中头结点大的元素,再进行链表连接
ListNode list1CurrentNode = leftNode.next;
ListNode list1ParentNode = leftNode;
ListNode list2CurrentNode = rightNode;
if(list1CurrentNode==null){
list1ParentNode.next = list2CurrentNode;
return list1;
}
while(list1CurrentNode.val<=list2CurrentNode.val){
list1ParentNode = list1CurrentNode;
list1CurrentNode = list1CurrentNode.next;
if(list1CurrentNode==null){
list1ParentNode.next = list2CurrentNode;
return list1;
}
}
list1ParentNode.next = list2CurrentNode;
return getResult(list1,list2CurrentNode,list1CurrentNode);
}
}