50 51 60 70

Author: LuYanFCP

README.md

@@ -41,9 +41,11 @@
 ## 动态规划
 
 + No.46 [cpp]()  [python](python/46_dp.py)
++ No.70 [cpp](cpp/70.cpp) [python](python/70.py)   easy
 + No.53 [cpp](cpp/53.cpp) [python](python/53.py)
 + No.120 [cpp](cpp/120.cpp) [python](python/120.py)
 + No.837 [cpp](cpp/837.cpp) [python](python/837.py)
++ No.126 [cpp](cpp/126.cpp) [python](python/126.py)
 
 ## 递归 
 
@@ -57,10 +59,11 @@
 
 ## 二分
 
++ No.50 快速幂 [cpp](cpp/50.cpp) [python](python/50.py)
 + No.128 [cpp](cpp/128.cpp) [python](python/128.py)
 
 ### 剑指offer系列
 
 + No.45 [cpp](#) [python](剑指offer/python/45.py)
-+ No.51 [cpp](剑指offer/cpp/51.cpp) [python]
++ No.51 [cpp](剑指offer/cpp/51.cpp) [python](剑指offer/python/51.py)
 + No.59 [cpp](剑指offer/cpp/59.cpp)

cpp/50.cpp

@@ -0,0 +1,50 @@
+#include <climits>
+#include <cmath>
+using namespace std;
+
+class Solution {
+public:
+    double myPow(double x, int n) {
+        /**
+         * 用时: 4ms
+         * 内存: 5.9MB
+         */
+        // printf("%d", INT_MIN);
+        bool flag = false;
+        if (n < 0) {
+            if (n != INT_MIN)
+                n = -n;
+            else {
+                n = -(n+1);
+                flag = true;
+            }
+            x = 1/x;
+        }
+        double base = x;
+        double res = 1.0;
+        for (;n; n = n >> 1, base *= base) {
+            if (n % 2) {
+                res *= base;
+            }
+        }
+        if (flag)
+            res *= x;
+        return res;
+    }
+    double myPow2(double x, int n) {
+        /*优化*/
+        /**
+         * 用时: 0ms
+         * 内存: 6MB
+        */
+        if (n == 1.0) return 1.0;
+        if (n < 0) x = 1/x;
+        unsigned int m = abs(n);   // 取代了复杂的变换
+        double res = 1.0;
+        double base = x;
+        for (; m; m = m>>1, base *= base) 
+            if (m%2) res *= base;
+        return res;
+    }
+
+};

cpp/51.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int climbStairs(int n) {
+        int a = 1;
+        int b = 1;
+        int temp;
+        for (int i = 2; i <= n; ++i) {
+            temp = b;
+            b = a + b;
+            a = temp;
+        }
+        return b;
+    }
+};

cpp/70.cpp

@@ -0,0 +1,14 @@
+class Solution:
+    def myPow(self, x: float, n: int) -> float:
+        # 快速幂算法
+        if n < 0:
+            x = 1/x
+            n = -n
+        base = x
+        res = 1.0
+        while n:
+            if n % 2:
+                res *= base
+            n = n >> 1
+            base *= base
+        return res

python/50.py

@@ -0,0 +1,103 @@
+def conflict(state, nextX):
+    nextY = len(state)
+    for i in range(nextY):
+        if abs(state[i] - nextX) in (0, nextY-i):
+            return True
+    return False
+
+def queens(num, state):
+    for pos in range(num):
+        if not conflict(state, pos):
+            if len(state) == num-1:
+                yield (pos, )
+            else:
+                for result in queens(num, state+(pos,)):
+                    yield (pos, ) + result
+
+def prettyprint(solution):
+    def line(pos, lenght=len(solution)):
+        return '.'*(pos) + 'Q' + '.' * (lenght-pos-1)
+    res = []
+    for pos in solution:
+        res.append(line(pos))
+
+
+class Solution:
+    def solveNQueens1(self, n: int) -> List[List[str]]:
+
+        res = []
+        for s in queens(num=n, state=()):
+            print(s)
+            res.append(prettyprint(s))
+        print(len(res))
+        return res
+
+    def solveNQueens2(self, n: int) -> List[List[str]]:
+        arr = list(range(n))
+
+        def _check(arr):
+            for i in range(0, n):
+                for j in range(i+1, n):
+                    if abs(i-j) == abs(arr[i] - arr[j]):
+                        return False
+            return True
+
+        _res = []
+        def _dfs(pos):
+
+            if pos == n-1:
+                if _check(arr):
+                    _res.append(arr[:])
+            else:
+                for i in range(pos, n):
+                    
+                    arr[pos], arr[i] = arr[i], arr[pos]
+                    _dfs(pos+1)
+                    arr[pos], arr[i] = arr[i], arr[pos]
+
+        _dfs(0)
+        res = []
+
+        def _replace(pos):
+            str_res = ['.']*n
+            str_res[pos] = 'Q'
+            return ''.join(str_res)
+
+        for res_one in _res:
+            res.append([_replace(i) for i in res_one])
+        return res
+    
+    def solveNQueens3(self, n: int) -> List[List[str]]:
+        
+        hashtable = [False] * (n+1)
+        P = list(range(n+1))
+        res = []
+
+        def _replace(pos):
+            str_res = ['.']*n
+            str_res[pos-1] = 'Q'
+            return ''.join(str_res)
+
+        def dfs(index):
+            if index == n+1:
+                temp = []
+                for i in range(1, n+1):
+                    temp.append(_replace(P[i]))
+                res.append(temp)
+            
+            for x in range(1, n+1):
+                if not hashtable[x]:
+                    flag = True
+                    for pre in range(1, index):
+                        if abs(index - pre) == abs(x - P[pre]):
+                            flag = False
+                            break
+        
+                    if flag:
+                        P[index] = x
+                        hashtable[x] = True
+                        dfs(index+1)
+                        hashtable[x] = False
+        dfs(1)
+        return res
+            

python/51.py

@@ -0,0 +1,6 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        a, b = 1, 1
+        for i in range(1, n):
+            a, b = b, a+b
+        return b

python/70.py

@@ -0,0 +1,35 @@
+class Solution:
+    def twoSum(self, n):
+        dp = [[0 for j in range(n*6+1)] for i in range(n)]
+        dp[0][1:6] = ([1] * 6)
+        for i in range(1, n):
+            for j in range(i, i*6+7):
+                for k in range(1, 7):
+                    if j >= k+i-1 and j-k <= 6*n: # 优化 因为 n 不需要再计算n-1
+                        dp[i][j] += dp[i-1][j-k]
+
+        res = []
+        for i in range(n, n*6+1):
+            res.append(dp[n-1][i]*1.0/6**n)
+        return res
+
+    def twoSum_2(self, n):
+        dp = [0 for j in range(n*6+1)]
+        dp[1:6] = ([1] * 6)
+        for i in range(2, n+1):
+            for j in range(i*6, i-1, -1):
+                dp[j] = 0
+                for k in range(1, 7):
+                    if j >= k+i-1 : # 优化
+                        dp[j] += dp[j-k]  # 压缩存储
+        res = []
+        for i in range(n, n*6+1):
+            res.append(dp[i]*1.0/6**n)
+        
+        return res
+
+
+
+if __name__ == "__main__":
+    s = Solution()
+    s.twoSum_2(2)