LeetCode 315. Count of Smaller Numbers After Self

又到一周更新时，这次的题目依旧来自LeetCode，由于这周老师还是讲的divide and conquer，按照以往的惯例，我从难度为hard的题目中挑选了一道通过率第二高的题，因为第一高的题上一次做了，所以这次的题目是315号题 Count of Smaller Numbers After Self，下面是题目介绍：

---------------------------------题目-----------------------------------------------

You are given an integer array nums and you have to return a new counts array.The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].

Example:

Given nums = [5, 2, 6, 1]

To the right of 5 there are 2 smaller elements (2 and 1).
To the right of 2 there is only 1 smaller element (1).
To the right of 6 there is 1 smaller element (1).
To the right of 1 there is 0 smaller element.

Return the array [2, 1, 1, 0].

-----------------------------------手动分割线-------------------------------------

那么老规矩，先看题，英语好的小朋友自行翻译。题目意思是有一个整数型数组nums，你给出的答案也是一个数组，你答案数组的第i个数的内容应该是nums数组中从第i个数开始有多少个数比这个第i个数小。题目很好理解，在样例中也给得很清楚了。

看到这个题后我想了很多种方法，比如建二叉树，很高端是不是？以第一个数为根节点，那么节点左侧就是所有比这个节点小的数了，这一点对于这棵树中的所有节点都适用，当然了，我最后用的不是这个方法，虽然说起来比较容易，但做起来还是比较麻烦的，对于我这么懒的人来说我是不愿意这么做的。虽然话是这么说，真正实现起来其实并不容易，树建好后，对整棵树进行遍历，找到所有节点对应的那一个数（答案要求的比这个节点小的数的个数），最后还有根据原数组的顺序来找到这个节点再把这个节点对应的答案加到你的答案数组中，时间复杂度并不是很好，实现起来也很麻烦，所以我果断放弃这一种方法。

第二种方法：根据高中数学老师教导的一种正难则反的思想，从前到后看起来比较麻烦，毕竟是要找到这个数之后的所有数中比这个数小的数的个数，那么如果我一开始就从最后做呢？首先最后一个数对应的答案肯定是0了，倒数第二个数呢？对应的答案肯定不是1就是0，看起来是不是简单了很多。那么思路就出来了，从数组末尾开始做，每添加前一个数后都要保证已经做完的这一部分数组是有序的，那么进行前一个数的时候，我就可以找到这么这一个数在后面这部分数组的位置，也就是下标，根据这一个下标我们就可以很容易地找到这个数对应的答案了，那么比较麻烦就是插入了，stl中有一个向量的插入函数，左思右想没有想到有什么可以避开插入这种插入的方法，除非使用链表，但是那么一来查找就比较麻烦了，其实主要是写起来比较麻烦。虽然这种方法已经是可以的了，我也打算用这种方法做，但是在写的过程中，我找到了第三种方法，也是我最后采用的方法。

方法三：高中数学老师教导我们正难则反，但小学语文老师却也教我们迎难而上，好吧，其实跟这些什么关系都没有，像我这么懒的人自然是怎么写起来简单怎么写啦，当然这种方法是方法二给我的灵感，最后我们得到的数组是有序的，那么我何必不一开始就直接对数组排序呢？然后从这个有序的数组中找到原始数组中从前面开始的那个数在有序数组中对应的下标，有了下标就知道对应的答案了，最后我们再在这个有序数组中删掉这个数，再同样操作后面的数。其实本质上和方法二差别不大，但是stl中对应的函数都有，不用自己排序，不用自己查找，不用自己删除，所以写起来很省事，我也就果断选择了这个方法。

下面是代码：

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

class Solution {
public:
	int bisearch(vector<int>arr,int left,int right,int element)  //二分查找，没什么好说的
	{  
		int mid;
    	while(left<=right)  
    	{     
        	mid = (left+right)/2;  
        	if(arr[mid]>element)  
        	{  
        	    right = mid - 1;  
        	}  
        	else if(arr[mid]<element)  
        	{  
            left = mid + 1;  
       		}  
    		else   
        	{  
        	   break;
        	}  
    	}  
    	while(mid-1>=0&&arr[mid]==arr[mid-1])//避免题目中有相同的数字出错，后面的稳定排序也是为了这一点，血淋淋的教训啊，被坑过
    	mid-=1;
    	return mid;	
	}  
    vector<int> countSmaller(vector<int>& nums) {
    	vector<int> copy;//源向量的副本，用于排序，源向量需要保留，用于记录原始顺序并得到最后答案向量的顺序
    	copy=nums;
    	stable_sort(copy.begin(),copy.end());//稳定排序，stl函数
    	vector<int> ans;
    	int l=nums.size();
    	for(int i=0;i<l;i++)
    	{
			int in=bisearch(copy,0,copy.size()-1,nums[i]);
			ans.push_back(in);
			copy.erase(copy.begin()+in);//在有序向量中删除已经处理的数
		}	
		return ans;
    }
};

由于题目的特殊性，我们不得不自己写二分查找，当然这也不是我自己写的，网上找到二分查找标准写法然后修改了一下 。题目中会出现几个相同的数，为了避免出错，所以二分查找做出了修改，会找到顺序靠前的目标的下标。选择稳定排序也是为了这个，不过看起来没有这个必要，向量删除的时间复杂度和插入一样，所以方法三和方法二时间复杂度差不多，但方法三写起来要简单不少。恩，差不多就是这样，我懒我骄傲，你管我。

----------------------------------手动分割线----------------------------------------

see you next illusion！！！