leecode 解题总结：220. Contains Duplicate III

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <unordered_map>
using namespace std;
/*
问题:
Given an array of integers, find out whether there are two distinct indices i and j 
in the array such that the absolute difference between nums[i] and nums[j] is at most t 
and the absolute difference between i and j is at most k.

分析:也就是说要寻找任意元素对应的下标i和j，满足i和j的差的绝对值<=k，两个数值的差值<=t
暴力破解：确定起始位置beg,在beg+k的范围中不断计算两个数的差值是否<=t。
时间复杂度：极端地，k=n,那么对于每个起始点，要遍历所有剩余节点，时间复杂度为O(n^2)
考虑到如果排序后，计算的起始点值为v,则另一个数值v-k,v+k,通过二分法定位到这个上下区间，
然后判定下标差值是否符合。总的时间复杂度为:
排序: O(NlogN)，寻找，O(logN)，遍历

输入:
3(数组元素个数) 2(k) 3(t)
7 1 3
1 2 3
1
3 2 3
1 5 10
2 1 2147483647
-1 2147483647
2 2 4
-3 3
输出:
true
false
false
false
false
关键：
1 被两数相减溢出坑了。面对简单的题目的加减法一定要考虑溢出
报错:Input:[-1,2147483647] 1 2147483647
Output:true
Expected:false

2还是溢出
//简单的题目：两个int数据相加减，需要先转化为long long,结果也要是long long,否则溢出
value1 = (long long)nums.at(i);
value2 = (long long)nums.at(j);
result = llabs(value1 - value2);
Input:
[2147483647,-2147483647]
1
2147483647
Output:
true
Expected:
false

3果然超时
参考这位:http://blog.csdn.net/Jeanphorn/article/details/46625729 的解法
题目是滑动窗口问题。
|nums(i) - nums(j)| <= t 【1】
|nums(i)/t - nums(j)/t| <= 1 【2】
所以nums(i)/t 属于{ nums(j)/t , nums(j)/t - 1 , nums(j)/t + 1 } 
只需要以 另key = nums(i)/t 作为键，以 nums(i)作为值存储，然后当前元素nums[i]和dict[key],dict[key-1]
dict[key+1]比较即可。
另外一旦 i >= k,删除窗口之外的键值，确保下标在合理范围
			//删除窗口以外的键值
			if(i >= k)
			{
				dict.erase( nums.at(i - k) / max(1, t) );
			}
		}
*/

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        if(nums.empty() || k <= 0 || t < 0 || 1 == nums.size())
		{
			return false;
		}
		int size = nums.size();
		unordered_map<int , long long> dict;
		for(int i = 0 ; i < size ; i++)
		{
			//注意t不能为0
			int key = nums.at(i) / max(1 ,t);
			if( ( dict.find(key) != dict.end() && llabs((long long)nums.at(i) - dict.at(key) ) <= t ) || 
				( dict.find(key - 1) != dict.end() && llabs((long long)nums.at(i) - dict.at(key - 1) ) <= t ) || 
				( dict.find(key + 1) != dict.end() && llabs((long long)nums.at(i) - dict.at(key + 1) ) <= t ) )
			{
				return true;
			}

			//找不到，需要插入键值对: nums(i) / max(1, t) ,存入的值是当前元素
			dict[key] = nums.at(i) ;

			//删除窗口以外的键值
			if(i >= k)
			{
				dict.erase( nums.at(i - k) / max(1, t) );
			}
		}
		return false;
    }
};

void print(vector<int>& result)
{
	if(result.empty())
	{
		cout << "no result" << endl;
		return;
	}
	int size = result.size();
	for(int i = 0 ; i < size ; i++)
	{
		cout << result.at(i) << " " ;
	}
	cout << endl;
}

void process()
{
	 vector<int> nums;
	 int value;
	 int num;
	 Solution solution;
	 vector<int> result;
	 int maxIndexDiff;
	 int maxValueDiff;
	 while(cin >> num >> maxIndexDiff >> maxValueDiff)
	 {
		 nums.clear();
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> value;
			 nums.push_back(value);
		 }
		 bool result = solution.containsNearbyAlmostDuplicate(nums , maxIndexDiff , maxValueDiff);
		 if(result)
		 {
			 cout << "true" << endl;
		 }
		 else
		 {
			 cout << "false" << endl;
		 }
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}