leetcode习题代码(经常更新)

为了准备面试编程题，我最近准备刷一刷leetcode，我是从191开始往前刷，把accept过的代码贴上来

leetcode 191

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int ans = 0;
        long long tmp = 1;
        while(tmp <= n)
        {
            if ((tmp & n) != 0)
            {
                ans ++;
            }
//            printf("tmp = %d tmp & n = %d\n",tmp,tmp & n);
            tmp <<= 1;
        }
        return ans;
    }
};

leetcode 190:

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
     long long ans = 0;
    long long tmp = 1;
    for (unsigned int i=1; i;i<<=1)
    {
        ans <<= 1;
        if (tmp & n)
        {
            ans ++;
        }
        tmp <<= 1;
    }
    return ans;
    }
};

189没看明白题目。不过看起来很简单的样子

leetcode 188，说实话，这题是我见过最奇怪的动态规划，像背包，但是又想不出好的解法，一时半会儿真弄不明白。有篇博客讲得不错：http://blog.csdn.net/linhuanmars/article/details/23236995

class Solution
{
public:
    int maxProfit(int k, vector<int> &prices)
    {
        int size = prices.size();
        if (k >= size)
        {
            int sum = 0;
            for (int i=1; i<size; i++)
            {
                sum += max(prices[i] - prices[i - 1],0);
            }
            return sum;
        }
        int local[k + 1];
        int global[k + 1];
        for (int i=0; i<=k; i++)
        {
            local[i] = global[i] = 0;
        }
        for (int i=0; i<size - 1; i++)
        {
            int length = prices[i + 1] - prices[i];
            for (int j=k; j>=1; j--)
            {
                local[j] = max(global[j - 1] + max(length,0),local[j] + length);
                global[j] = max(global[j],local[j]);
            }
        }
        return global[k];
    }
};

leetcode 187

这题坑爹的地方，我用hash居然报MLE，我把数组开到最小居然还报，后来改成map才过，这烂judge真坑爹！

下面是hash+vector版本:

class Solution {
public:
    
vector<string> f[10000];


int get_num(char c)
{
    int ans = 0;
    switch (c)
    {
    case 'A':
    {
        ans = 1;
        break;
    }
    case 'G':
    {
        ans = 2;
        break;
    }
    case 'C':
    {
        ans = 3;
        break;
    }
    case 'T':
    {
        ans = 4;
        break;
    }
    }
    return ans;
}

long long get_sum(int num)
{
    long long ans = num;
    for (int i=0; i<9; i++)
    {
        ans *= 10;
    }
    return ans;
}


vector<string> findRepeatedDnaSequences(string s)
{
    vector<string> ans;
    int size = s.length();

    int mod = 9997;
    long long sum = 0;
    long long sum1 = 0;
    int start = 0,tail = 10;
    if(s == "" || size == 0)
    {
        printf("size = %d\n",size);
        return ans;
    }
    for (int i=0; i<10; i++)
    {
        int tmp = get_num(s[i]);
        sum1 *= 10;
        sum1 += tmp;
        sum = sum1 % mod;
    }
    if (size > tail)
    {
        f[sum].push_back(s.substr(0,10));;
        start = 1;
        while(tail < size)
        {
            sum1 -= (get_sum(get_num(s[start - 1])));;
            sum1 *= 10;
            sum1 += get_num(s[tail]);
            sum = sum1 % mod;
            if (f[sum].size() > 0)
            {
                for (int i=0; i<f[sum].size(); i++)
                {
                    if (f[sum][i] == s.substr(start,10))
                    {
                        ans.push_back(s.substr(start,10));
                    }
                    else
                    {
                        f[sum].push_back(s.substr(start,10));
                    }
                }
            }
            else
            {
                f[sum].push_back(s.substr(start,10));
            }
            start ++;
            tail ++;
        }
    }
    return ans;
}
};//mle

AC版本map:

int get_num(char c)
{
    int ans = 0;
    switch (c)
    {
    case 'A':
    {
        ans = 1;
        break;
    }
    case 'G':
    {
        ans = 2;
        break;
    }
    case 'C':
    {
        ans = 3;
        break;
    }
    case 'T':
    {
        ans = 4;
        break;
    }
    }
    return ans;
}

long long get_sum(int num)
{
    long long ans = num;
    for (int i=0; i<9; i++)
    {
        ans *= 10;
    }
    return ans;
}


vector<string> findRepeatedDnaSequences(string s)
{
    vector<string> ans;
    int size = s.length();

    int mod = 990023;
    long long sum = 0;
    long long sum1 = 0;
    map<long long,int> m;
    int start = 0,tail = 10;
    if(s == "" || size == 0)
    {
        return ans;
    }
    for (int i=0; i<10; i++)
    {
        int tmp = get_num(s[i]);
        sum1 *= 10;
        sum1 += tmp;
    }
    m[sum1] ++;
    if (size > tail)
    {
        start = 1;
        while(tail < size)
        {
            sum1 -= (get_sum(get_num(s[start - 1])));;
            sum1 *= 10;
            sum1 += get_num(s[tail]);
            if (m[sum1] > 0)
            {
                if (m[sum1] == 1)
                ans.push_back(s.substr(start,10));
            }
            m[sum1]++;
            start ++;
            tail ++;
        }
    }
//    for (int i=0; i<ans.size(); i++)
//    {
//        cout<<ans[i]<<endl;
//    }
    return ans;
}

两种解法时间复杂度都是O(n);

leetcode 179

这题有两种方案，一是搜索，但无疑会Tle，另一种是排序，两个方案的思想都很好，不针对题目，将两个方案的代码都列出来:

1.搜索代码TLE:

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;


string int2str(int num)
{
    int tmp = 0;
    string ans;
    char s[100];
    int length = 0;
    while(num > 0)
    {
        tmp = num % 10;
        s[length++] = (tmp + '0');
        num /= 10;
    }
    s[length] = '\0';
    reverse(s,s+length);
    ans = s;
//    cout<<"ans = "<<ans<<endl;
    return ans;
}
string ans;

bool vis[10010];

void get_ans(vector<int> &num,string tmp,int n)
{
    int size = num.size();
    if (n == num.size() - 1)
    {
        if (ans < tmp)
        {
            ans = tmp;
        }
        return ;
    }
    for (int i=0; i<size; i++)
    {
        if (vis[i] == 0)
        {
            vis[i] = 1;
            get_ans(num,tmp + int2str(num[i]),n + 1);
            vis[i] = 0;
        }
    }
}

string largestNumber(vector<int> &num)
{
   get_ans(num,"",0);
   return ans;
}

int main()
{
    memset(vis,0,sizeof(vis));
    vector<int> num;
    for (int i=0; i<6; i++)
    {
        num.push_back(i);
    }
    largestNumber(num);
    cout<<"ans = " <<ans<<endl;
    return 0;
}

2。java排序方法

public class Solution {
   public static String largestNumber(int[] num) {
		int length = num.length;
		String[] ans = new String[length];
		for (int i=0; i<length; i++)
		{
			ans[i] = num[i] + "";
		}
		Arrays.sort(ans,new MyCompare());
		String res = "";
		for (int i=0; i<length; i++)
		{
			res += ans[i];
		}	int index = -1;
		for (int i=0; i<res.length(); i++)
		{
			if (res.charAt(i) == '0')
			{
				index = i;
			}
			else
			{
			    break;
			}
		}
		if (index != -1)
			return res.substring(index);
		else {
			return res;
		}
	}
}

class MyCompare implements Comparator<String>
{

	public int compare(String o1, String o2) {
		String s1 = (String) o1;
		String s2 = (String) o2;
		int res = (s1 + s2).compareTo(s2 + s1);
		if (res < 0)
			return 1;
		else {
			return -1;
		}
	}

}

leetcode 174比较简单的dp

public int calculateMinimumHP(int[][] dungeon) {  
        int m = dungeon.length;  
        int n = dungeon[0].length;  
          
        int[][] ans = new int[m][n];  
          
        ans[m - 1][n - 1] = dungeon[m - 1][n - 1] > 0 ? 0 : -dungeon[m - 1][n - 1];  
        for (int i = m - 2; i >= 0; i--) {  
            ans[i][n - 1] = dungeon[i][n - 1] >= ans[i + 1][n - 1] ? 0 : ans[i + 1][n - 1] - dungeon[i][n - 1];  
        }  
        for (int j = n - 2; j >= 0; j--) {  
            ans[m - 1][j] = dungeon[m - 1][j] >= ans[m - 1][j + 1] ? 0 : ans[m - 1][j + 1] - dungeon[m - 1][j];  
        }  
          
        for (int i = m - 2; i >= 0; i--) {  
            for (int j = n - 2; j >= 0; j--) {  
                int down = dungeon[i][j] >= ans[i + 1][j] ? 0 : ans[i + 1][j] - dungeon[i][j];  
                int right = dungeon[i][j] >= ans[i][j + 1] ? 0 : ans[i][j + 1] - dungeon[i][j];  
                ans[i][j] = Math.min(down, right);  
            }  
        }  
          
        return ans[0][0] + 1;  
    }