<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[X___J的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/X___J</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; X___J]]></copyright><item><title><![CDATA[62. Unique Paths]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/53021228</link><guid>https://blog.youkuaiyun.com/X___J/article/details/53021228</guid><author>X___J</author><pubDate>Thu, 03 Nov 2016 14:50:14 +0800</pubDate><description><![CDATA[题目大意：m*n的阵列，求从（1,1）到（m,n）路径的总数。
大致思路：
1.排列组合：（m-1）个行和（n-1）个列的排列组合，需要注意的是，要用double保存结果，int保存结果容易上限溢出。
2.递归：uniquePaths(m,n)=uniquePaths(m-1,n)+uniquePaths(m,n-1),测试结果TLE；
改进uniquePaths(m,n)=uniqueP]]></description><category></category></item><item><title><![CDATA[406. Queue Reconstruction by Height]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52980222</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52980222</guid><author>X___J</author><pubDate>Mon, 31 Oct 2016 10:29:04 +0800</pubDate><description><![CDATA[题目大意：有一队人，每个人由一个（h,k）表示，h表示高度，k表示前面高于或等于自己的人个人。给一个打乱了的队列，求出正确的序列。
思路：
1.每次从队列中找出k=0，再在其中选出h最小的，加入到res队列中；然后对剩余队列做相应的处理；再循环，即可求出全部队列，类似于递归。176ms
2.先把队列按h从大到小，h相同则k从小到大的顺序排列，然后依次将每个人插入到res队列。83ms
CO]]></description><category></category></item><item><title><![CDATA[242. Valid Anagram]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52838939</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52838939</guid><author>X___J</author><pubDate>Mon, 17 Oct 2016 15:16:02 +0800</pubDate><description><![CDATA[题目大意：给定两个字符串，判断是否由相同的元素构成，除了顺序不同以外。
大概思路：先排序，再比较。
主要记录下使用系统自带qsort的方法。
code：

int cmp(const void *a, const void *b)
{ 
    return(*(char *)a-*(char *)b);
}
bool isAnagram(char* s, char* t) {]]></description><category></category></item><item><title><![CDATA[198. House Robber]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52788459</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52788459</guid><author>X___J</author><pubDate>Tue, 11 Oct 2016 15:31:15 +0800</pubDate><description><![CDATA[题目大意：给定一个整数数组（非负），取其中一些数，和值最大。要求不能取相邻的数。
思路：
1.递归；结果超时
2.动态规划。
对比两者，递归列举的情况太多，效率太低，后续队列的情况太多。
用动态规划，求出到每一个数为止最大的和值，找到递进的公式，用前面已知的和值加上当前的单值。
一种是利用前面的已知，一种是依赖后续的未知，因此效率差别太大。
动态规划最重要的是递进关系。
CODE:]]></description><category></category></item><item><title><![CDATA[258. Add Digits]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52766555</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52766555</guid><author>X___J</author><pubDate>Sun, 09 Oct 2016 14:34:58 +0800</pubDate><description><![CDATA[题目大意：给一个非负整数，需要将其每个位置上的数字相加，若结果仍然大于10，继续相加，直到结果为个位数为知。要求时间复杂度o(1).
思路：自己想了一会，没有想出来，感觉很有意思，就记录下来。
把1~20的结果写出来，发现每9个一个循环。
代码就一行就搞定了
return (num-1)%9+1;]]></description><category></category></item><item><title><![CDATA[396. Rotate Function]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52757171</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52757171</guid><author>X___J</author><pubDate>Sat, 08 Oct 2016 16:08:51 +0800</pubDate><description><![CDATA[题目大意：给定数组A，长度为ASize，分别用【0~ASize-1】作为各项的系数，求最大值。例子比较明了

A = [4, 3, 2, 6]

F(0) = (0 * 4) + (1 * 3) + (2 * 2) + (3 * 6) = 0 + 3 + 4 + 18 = 25
F(1) = (0 * 6) + (1 * 4) + (2 * 3) + (3 * 2) = 0 + 4 + 6 +]]></description><category></category></item><item><title><![CDATA[142. Linked List Cycle II]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52681287</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52681287</guid><author>X___J</author><pubDate>Tue, 27 Sep 2016 15:47:50 +0800</pubDate><description><![CDATA[题目大意：给定一个单链表，找出其环路的起始点。若不存在环路，则返回NULL。
大概思路：数学题
头结点是A，题目要求的环路起点为B，在141题快慢指针算法中求出的相遇点为C。
设A到B的距离为a,B到C的距离为b，环路一圈的距离为c。
则(a+b)*2=a+b+k*c;(其中k为常数)
则a+b=k*c;
两个指针分别以相同速度从A、B出发，第一个指针到达B点，路程为a，第二个指针此时]]></description><category></category></item><item><title><![CDATA[141. Linked List Cycle]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52678988</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52678988</guid><author>X___J</author><pubDate>Tue, 27 Sep 2016 11:12:07 +0800</pubDate><description><![CDATA[-----------------------------------------------------------------------------待续----------------------------------------------------------------------------------------------------
题目大意：给定一个单链表，判断是否存在]]></description><category></category></item><item><title><![CDATA[125. Valid Palindrome (暴力)]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52670928</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52670928</guid><author>X___J</author><pubDate>Mon, 26 Sep 2016 15:47:25 +0800</pubDate><description><![CDATA[题目大意：给定一个数组，只考虑字母和数字，且不考虑大小写区别，判断是不是回文串。
思路：暴力。
code：

bool isPalindrome(char* s) {
     int len=strlen(s);
     if(len<=1) return 1;
     int i=0;
     int j=len-1;
     while(i<j){]]></description><category></category></item><item><title><![CDATA[136. Single Number]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52670873</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52670873</guid><author>X___J</author><pubDate>Mon, 26 Sep 2016 15:44:35 +0800</pubDate><description><![CDATA[题目大意：一个整数数组，每个元素都出现了2次，只有一个元素出现了一次；find it.
基本思路：一道easy题，且通过率超过50%，但是没有想出来....尴尬...
code:

int singleNumber(int* nums, int numsSize) {
    int i=0;
    int res=0;
    while(i<numsSize){]]></description><category></category></item><item><title><![CDATA[122. Best Time to Buy and Sell Stock II]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52670260</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52670260</guid><author>X___J</author><pubDate>Mon, 26 Sep 2016 14:55:02 +0800</pubDate><description><![CDATA[题目大意：类似于上一题，只不过将只能交易一次的限制放宽为可以交易无限多次。
整体思路：将代码做了一点小小的修改就可以了。

int maxProfit(int* prices, int pricesSize) {
    int i,start,end;
    int res=0;
    if(pricesSize<=1) return 0;
    for(i=1,start=]]></description><category></category></item><item><title><![CDATA[121. Best Time to Buy and Sell Stock]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/52668722</link><guid>https://blog.youkuaiyun.com/X___J/article/details/52668722</guid><author>X___J</author><pubDate>Mon, 26 Sep 2016 11:35:08 +0800</pubDate><description><![CDATA[题目大意：给定一个一直序列，求出最大差值，注意只能由后面的数减前面的数。例如：
[7, 1, 5, 3, 6, 4]

6-1，输出答案5；

[7, 6, 4, 3, 1]
输出0.
基本思路：暴力解法，需要o(n2)的时间复杂度。
优化解法，时间复杂度o(n):

int maxProfit(int* prices, int pricesSize) {
    int i,]]></description><category></category></item><item><title><![CDATA[11. Container With Most Water]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/51956978</link><guid>https://blog.youkuaiyun.com/X___J/article/details/51956978</guid><author>X___J</author><pubDate>Tue, 19 Jul 2016 16:38:39 +0800</pubDate><description><![CDATA[题目大意：
坐标轴上，有n个点，坐标分别是(1,a1)、(2,a2)...(n,an),其中，纵坐标均是非负整数。
从中选取两个坐标，使其与x轴形成一个盛水容器，求最大的盛水量，注意，斜面不能盛水。
大致思路：
刚开始，用的是暴力解法，分别取距离为1/2/3/4/5...n，然后取最大值，时间复杂度为O(n2),在测试集合比较大的情况下会超时。
后面，参考网上的方法，大致想法如下.
1]]></description><category></category></item><item><title><![CDATA[263. Ugly Number]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/51700229</link><guid>https://blog.youkuaiyun.com/X___J/article/details/51700229</guid><author>X___J</author><pubDate>Fri, 17 Jun 2016 15:24:38 +0800</pubDate><description><![CDATA[题目大意：
判断一个数是不是丑数。丑数的定义是，其素数因子中只能包含2,3,5，不能有更大的素数。同时，1是丑数。
思路：
用2,3,5不断的整除给定的数后，若剩下的数是1，则该数为丑数。反之，则不为丑数。
若剩下的不为1，说明剩下的因子是比2,3,5大的素数或者乘积。
code:

bool isUgly(int num) {
        if (num == 1) retu]]></description><category></category></item><item><title><![CDATA[328. Odd Even Linked List]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/51595331</link><guid>https://blog.youkuaiyun.com/X___J/article/details/51595331</guid><author>X___J</author><pubDate>Mon, 06 Jun 2016 14:35:40 +0800</pubDate><description><![CDATA[中等难度
题目大意：给定单链表，更换排列顺序，将原来位置1234567，更换为1357246.要求空间复杂度为o(1),时间复杂度为o(n).
思路：暴力...
code：

struct ListNode* oddEvenList(struct ListNode* head) {
    struct ListNode *p1, *odd, *even;
    if(!head|]]></description><category></category></item><item><title><![CDATA[319. Bulb Switcher]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/51593392</link><guid>https://blog.youkuaiyun.com/X___J/article/details/51593392</guid><author>X___J</author><pubDate>Mon, 06 Jun 2016 09:51:58 +0800</pubDate><description><![CDATA[这居然又是一道中等难度的题....
题目大意：n个灯泡，刚开始的时候全部关闭，每第i轮，将能被i整除的灯泡改变状态，即，
第1轮，打开所有灯泡；
第2轮，关闭灯泡2,4,6,8...
第3轮，打开灯泡3,6,9...
...
第n轮，改变灯泡n 的状态，
最后返回亮着的灯泡数目。
思路：每个数i，能分解为各个因子，在每个因子那一轮，都被改变状态，只有平方数，最后亮着，例如，
12]]></description><category></category></item><item><title><![CDATA[268. Missing Number]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/51593262</link><guid>https://blog.youkuaiyun.com/X___J/article/details/51593262</guid><author>X___J</author><pubDate>Mon, 06 Jun 2016 09:32:01 +0800</pubDate><description><![CDATA[这居然是一道中等难度的题。。。
题目大意：给定一个数组，长度为n，其中数字为0~n中的n个，返回缺少的那一个，要求时间复杂度为线性，空间复杂度为常数。
思路：求出数组的和，然后，用n*(n+1)/2减去总和就行了...
code:

int missingNumber(int* nums, int numsSize) {
    long total=0;
    int i;]]></description><category></category></item><item><title><![CDATA[283. Move Zeroes]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/51593094</link><guid>https://blog.youkuaiyun.com/X___J/article/details/51593094</guid><author>X___J</author><pubDate>Mon, 06 Jun 2016 08:52:19 +0800</pubDate><description><![CDATA[题目大意：给定一个整数数组，将数组中所有的0移到数组尾部，保持其他非0数的顺序不变，要求是空间复杂度为o(1).
思路：循环数组一遍，依次找到第一个为0的位置和第一个非0的位置，进行处理。
code：

void moveZeroes(int* nums, int numsSize) {
    int i,j,temp;
    if(numsSize<1) return;]]></description><category></category></item><item><title><![CDATA[342. Power of Four]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/51578982</link><guid>https://blog.youkuaiyun.com/X___J/article/details/51578982</guid><author>X___J</author><pubDate>Fri, 03 Jun 2016 15:01:24 +0800</pubDate><description><![CDATA[题目大意：判断一个整数num是不是4的指数，不用循环和递归的情况下。
思路：（借鉴）
4指数的整数的二进制表示只有1个1.其他全为0，于是num&(num-1)=0
4^n可以分解为3*（4^0+4^1+4^2...+4^(n-1)）,于是(num-1)%3=0，貌似这一步可以更优化，采用位运算代替取模。
code：

bool isPowerOfFour(int num) {]]></description><category></category></item><item><title><![CDATA[345. Reverse Vowels of a String]]></title><link>https://blog.youkuaiyun.com/X___J/article/details/51576594</link><guid>https://blog.youkuaiyun.com/X___J/article/details/51576594</guid><author>X___J</author><pubDate>Fri, 03 Jun 2016 09:48:42 +0800</pubDate><description><![CDATA[题目大意：给定一个字符串，反转其中的元音字母。
思路：头尾反转即可
code:

char* reverseVowels(char* s) {
    int len = strlen(s);
    int i=0;
    int j=len-1;
    char temp;
    while(i<j){
        while((s[i]!='a')&&(s[i]]]></description><category></category></item></channel></rss>