lintcode:组成最大的数

最大数

给出一组非负整数,重新排列他们的顺序把他们组成一个最大的整数。

注意事项

最后的结果可能很大,所以我们返回一个字符串来代替这个整数。

样例

给出 [1, 20, 23, 4, 8],返回组合最大的整数应为8423201

解题

本质上是一种排序,但是排序规则如何定义?

对于20 23 可以组成2023 和2320 显然2320更大应该排在前面

对于5 51 可以组成551 和 515 显然551更大应该排在前面

所以在比较两个数大小的规则应该将两个数链接起来后再比较大小

对于left、right

我们应该比较:leftright 和rightleft 的大小

通过字符串比较如下

public class Solution {
    /**
     *@param num: A list of non negative integers
     *@return: A string
     */
    public String largestNumber(int[] num) {
        // write your code here
        ArrayList<String> list = new ArrayList<String>();
        for(int i:num)
            list.add(i+"");
        Collections.sort(list,new Comparator<String>(){
            public int compare(String left,String right){
                String leftright = left + right;
                String rightleft = right + left;
                return leftright.compareTo(rightleft);
            }
        });
        String result="";
        for(int i =list.size()-1;i>=0;i--)
            result+= list.get(i);
        // if(result.equals("00") ||result.equals("0000")||result.equals("00000"))
        //     return "0";
        // 去除左边无效的 0
        int i = 0;
        while(i< result.length() && result.charAt(i) ==‘0‘)
            i++;
        if(i==result.length())
            return "0";
        return result.substring(i);
    }
}

修改快排的规则

public class Solution {
    /**
     *@param num: A list of non negative integers
     *@return: A string
     */
    public String largestNumber(int[] num) {
        // write your code here
        String result = "";
        quickSort(num,0,num.length - 1);
        for(int i = 0;i<num.length;i++)
            result += num[i];
        // 去除左边无效的 0
        int i = 0;
        while(i< result.length() && result.charAt(i) ==‘0‘)
            i++;
        if(i==result.length())
            return "0";
        return result.substring(i);
    }
    // 可以理解为逆序排序,排序后直接链接起来就是答案
    public void quickSort(int[] num,int low,int high){
        if(low>high)
            return;
        // for(int kk:num)
        //     System.out.print(kk+"  ");
        // System.out.println();
        int i= low;
        int j= high;
        int x = num[i];
        while(i<j){
            while(i<j && compare(x,num[j]))
                j--;
            if(i<j){
                num[i] = num[j];
                i++;
            }
            while(i<j && compare(num[i],x))
                i++;
            if(i<j){
                num[j] = num[i];
                j--;
            }
        }
        num[i] = x;
        quickSort(num,low,i-1);
        quickSort(num,i+1,high);
    }
    // AB > BA 说明A应该在前面,B应该在后面
    public boolean compare(int A,int B){
            String left = A+"";
            String right =B+"";
            String leftright = left + right;
            String rightleft = right + left;
            return leftright.compareTo(rightleft) >0;
    }
}
时间: 2024-10-07 14:40:01

lintcode:组成最大的数的相关文章

lintcode 落单的数(位操作)

题目1 落单的数 给出2*n + 1 个的数字,除其中一个数字之外其他每个数字均出现两次,找到这个数字. 链接:http://www.lintcode.com/zh-cn/problem/single-number/ 样例 给出 [1,2,2,1,3,4,3],返回 4 挑战 一次遍历,常数级的额外空间复杂度 解决方案 方法1思路:将所有的数转换成二进制,因为是int类型,共32位.申请常数级(32位)的额外空间,然后每个数对应的位相加,最后对应位上的和模2.最后的结果就是单个数对应的二进制数.

[LintCode] 寻找缺失的数

1 class Solution { 2 public: 3 /** 4 * @param nums: a vector of integers 5 * @return: an integer 6 */ 7 int findMissing(vector<int> &nums) { 8 // write your code here 9 int n = nums.size(); 10 int number = 0; 11 for (int i = 0; i <= n; i++) 1

[LintCode] Two Sum 两数之和

Given an array of integers, find two numbers such that they add up to a specific target number. The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that

[LintCode] Happy Number 快乐数

Write an algorithm to determine if a number is happy. A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number

[LintCode] Ugly Number 丑陋数

Write a program to check whether a given number is an ugly number`. Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. For example, 6, 8 are ugly while 14 is not ugly since it includes another prime factor 7. Notice Note that

两指针--减少数组循环

题目(lintcode): 1.二数之和 2.三数之和 3.最接近的三数之和 4.四数之和  取三数之和为例: (一) 普通算法,多重遍历数组,需要多重for嵌套,但严重超时. (二) 剪枝,在外层循环中考虑有没有“不可能符合要求”的情况. 例如,在三数之和中,若两个数之和大于0,直接break.但题目没说不会出现负数,所以不对. (三) 接(二),判断两个数之和大于0无效,是因为数组无序,所以先进行排序  sort(nums.begin(),nums.end()); 之后可以在保证大于0时,b

[LintCode/LeetCode]——两数和、三数和、四数和

LintCode有大部分题目来自LeetCode,但LeetCode比较卡,下面以LintCode为平台,简单介绍我AC的几个题目,并由此引出一些算法基础. 1)两数之和(two-sum) 题目编号:56,链接:http://www.lintcode.com/zh-cn/problem/two-sum/ 题目描述: 给一个整数数组,找到两个数使得他们的和等于一个给定的数 target. 你需要实现的函数twoSum需要返回这两个数的下标, 并且第一个下标小于第二个下标.注意这里下标的范围是 1

[Lintcode two-sum]两数之和(python,双指针)

题目链接:http://www.lintcode.com/zh-cn/problem/two-sum/ 给一个整数数组,找到两个数使得他们的和等于一个给定的数target. 备份一份,然后排序.搞两个指针分别从左从右开始扫描,每次判断这两个数相加是不是符合题意,如果小了,那就把左边的指针向右移,同理右指针.然后在备份的数组里找到位置. 1 class Solution: 2 """ 3 @param numbers : An array of Integer 4 @param

LintCode 249. 统计前面比自己小的数的个数

给定一个整数数组(下标由 0 到 n-1, n 表示数组的规模,取值范围由 0 到10000).对于数组中的每个 ai 元素,请计算 ai 前的数中比它小的元素的数量. 注意事项 We suggest you finish problem Segment Tree Build, Segment Tree Query II and Count of Smaller Number first. 样例 对于数组[1,2,7,8,5] ,返回 [0,1,2,3,2] 解题思路: 题目提示我们使用线段树,