记一次leetcode绕弯弯

 一、问题分析

这道题目虽然是简单题，不过这有点像是脑筋急转弯，一不小心就会掉进坑里。如果按照常规思维，这道问题就只能枚举了，可是最终枚举的效果却是时间超时。

但只要稍加思考此问题便能发现，既然是k个子序列，那么这k个子序列必然是这序列里的任意组合，那么可想而知一定存在着k个组合，而这k个组合分别是这个数组中前k大的数。那么问题就直接转换成求数组中前k个大的数了。

第一种超时办法：

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var maxSubsequence = function(nums, k) {
    let point_k = [];
    let max_result = -99999;
    let result = [];
    
    for(let j = 0; j < k; j++) {
        point_k.push(j);
    }
    while(point_k[0] <= nums.length - k)
    {
        let res = 0;
        let start = k - 1;
    
        for(let u = point_k.length - 1; u >= 0; u--) {
            if(point_k[u] > nums.length - (k - u)) {
                if(u <= 0) {
                    break;
                }
                
                point_k[u-1]++;
                for(let f = u; f < k; f++) {
                    point_k[f] = point_k[u-1] + f- u + 1;
                }
            } else {
                start = u;
                break;
            }
        }

        for(let f = start+1; f < k; f++) {
            point_k[f] = point_k[f] + f-start;
        }

        for(let n = 0; n < k; n++) {
           res += nums[point_k[n]];
        }
        
        if(res > max_result) {
            max_result = res;
            result = JSON.parse(JSON.stringify(point_k));
        }

        point_k[k-1]++;
    }
    
    let seq = [];
    
    for(let n = 0; n < result.length; n++) {
        seq.push(nums[result[n]]);
    }
    
    return seq;
};

第二种通过：

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var maxSubsequence = function(nums, k) {
    let tmp_nums = JSON.parse(JSON.stringify(nums));
    let s = nums.sort((a,b)=>{ return a - b;});
    let seq = [];
    let no = [];
    for(let i = s.length - 1; i >= s.length - k;i--) {
        seq.push(s[i]);
    }
    let rem = [];
    for(let j = 0; j < seq.length; j++) {
        rem[seq[j]] = tmp_nums.indexOf(seq[j],rem[seq[j]] + 1 || 0);
        no.push(rem[seq[j]]);
    }
    let sort_no = no.sort((a,b)=>{ return a - b;});
    seq = [];
    for(let n = 0; n < sort_no.length; n++) {
        seq.push(tmp_nums[sort_no[n]]);
    }
    return seq;
};

三、总结

有些时候看问题不能想当然，还是要经过思考，就像谈恋爱一样，要仔细谨慎思考合不合适再做决定。