安置路燈
題目描述
小Q正在給一條長度爲n的道路設計路燈安置方案。
爲了讓問題更簡單,小Q把道路視爲n個方格,需要照亮的地方用’.'表示, 不需要照亮的障礙物格子用’X’表示。
小Q現在要在道路上設置一些路燈, 對於安置在pos位置的路燈, 這盞路燈可以照亮pos - 1, pos, pos + 1這三個位置。
小Q希望能安置儘量少的路燈照亮所有’.'區域, 希望你能幫他計算一下最少需要多少盞路燈。
輸入描述:
輸入的第一行包含一個正整數t(1 <= t <= 1000), 表示測試用例數
接下來每兩行一個測試數據, 第一行一個正整數n(1 <= n <= 1000),表示道路的長度。
第二行一個字符串s表示道路的構造,只包含’.‘和’X’。
輸出描述:
對於每個測試用例, 輸出一個正整數表示最少需要多少盞路燈。
示例1
輸入
2
3
.X.
11
…XX…XX
輸出
1
3
解法
比較簡單的貪心算法，判斷好邊界條件即可
t = int(input().strip())
for _ in range(t):
n = int(input().strip())
s = input().strip()
res = 0
flag = 0
for i in range(n):
if flag == 0 and s[i] == '.':
if i == n - 1:
res += 1
else:
flag = 1
elif flag == 1:
res += 1
flag = 2
elif flag == 2:
flag = 0
print(res)
牛妹的蛋糕
題目描述
衆所周知，牛妹非常喜歡喫蛋糕。
第一天牛妹喫掉蛋糕總數三分之一多一個，第二天又將剩下的蛋糕喫掉三分之一多一個，以後每天喫掉前一天剩下的三分之一多一個，到第n天準備喫的時候只剩下一個蛋糕。
牛妹想知道第一天開始喫的時候蛋糕一共有多少呢？
示例1
輸入
2
輸出
3
示例2
輸入
4
輸出
10
備註:
0<n< 30
解法
動態規劃的思路，實際上反過來想，第一天是1，求第n天的總數。
#
#
# @param n int整型 只剩下一隻蛋糕的時候是在第n天發生的．
# @return int整型
#
class Solution:
def cakeNumber(self , n ):
# write code here
# x = y - (y / 3 + 1), y = (x + 1) * 3 / 2
res = 1
for i in range(n - 1):
res = int((res + 1) * 3 / 2)
return res
牛妹的禮物
題目描述
衆所周知，牛妹有很多很多粉絲，粉絲送了很多很多禮物給牛妹，牛妹的禮物擺滿了地板。
地板是N\times MN×M的格子，每個格子有且只有一個禮物，牛妹已知每個禮物的體積。
地板的座標是左上角(1,1) 右下角（N, M）。
牛妹只想要從屋子左上角走到右下角，每次走一步，每步只能向下走一步或者向右走一步或者向右下走一步
每次走過一個格子，拿起（並且必須拿上）這個格子上的禮物。
牛妹想知道，她能走到最後拿起的所有禮物體積最小和是多少？
示例1
輸入
[[1,2,3],[2,3,4]]
輸出
7
說明
(1,1)->(1,2)->(2,3)
備註:
0<N,M<300
每個禮物的體積小於100
解法
動態規劃
#
#
# @param presentVolumn int整型二維數組 N*M的矩陣，每個元素是這個地板磚上的禮物體積
# @return int整型
#
class Solution:
def selectPresent(self , presentVolumn ):
# write code here
if not presentVolumn:
return 0
N, M = len(presentVolumn), len(presentVolumn[0])
dp = [[0 for i in range(M)] for j in range(N)]
for i in range(N):
for j in range(M):
if i > 0 and j > 0:
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + presentVolumn[i][j]
elif i > 0 :
dp[i][j] = dp[i - 1][j] + presentVolumn[i][j]
elif j > 0 :
dp[i][j] = dp[i][j - 1] + presentVolumn[i][j]
else:
dp[i][j] = presentVolumn[i][j]
return dp[N - 1][M - 1]
最大數
題目描述
給定一個包含大寫英文字母和數字的句子，找出這個句子所包含的最大的十六進制整數，返回這個整數的值。數據保證該整數在int表示範圍內
示例1
輸入
“012345BZ16”
輸出
1193051
說明
12345B對應十進制爲1193051
備註:
0<字符串長度<=105
解法
不要用字符串進行大小的比較，直接轉成數字來比，時間夠
#
#
# @param s string字符串
# @return int整型
#
class Solution:
def solve(self , s ):
# write code here
tmp = ""
res = 0
chars = [str(x) for x in range(10)] + ['A', 'B', 'C', 'D', 'E', 'F']
for i in range(len(s)):
if s[i] in chars:
tmp += s[i]
else:
if tmp != "":
res = max(res, self.c2int(tmp))
tmp = ""
return res
def c2int(self, res):
num = 0
for i in range(len(res)):
x = res[i]
if x in [str(x) for x in range(10)]:
x = int(x)
else:
x = 10 + (ord(x) - ord('A'))
num = num * 16 + x
return num
神奇的數字
題目描述
在這個特殊的假期裏，由於牛牛在家特別無聊，於是他發明了一個小遊戲，遊戲規則爲：將字符串數字中爲偶數位的數字進行翻轉，將翻轉後的結果進行輸出。
示例1
輸入
“1234”
輸出
“1432”
說明
第2、4位爲偶數，所以將其翻轉後，得到 1432
示例2
輸入
“12346”
輸出
“16342”
說明
第2、4、5位爲偶數，所以將其翻轉後，得到 16342
備註:
數字的長度<=10^7 且不包含數字0
解法
就是個雙指針，一個從左往右，一個從右往左，遇到偶數就交換一下。
#
#
# @param number string字符串
# @return string字符串
#
class Solution:
def change(self , number ):
# write code here
if not number or len(number) == 1:
return number
nums = [int(x) for x in number]
i, j = 0, len(nums) - 1
while i < j:
while i < j and nums[i] % 2 == 1:
i += 1
while i < j and nums[j] % 2 == 1:
j -= 1
nums[i], nums[j] = nums[j], nums[i]
i += 1
j -= 1
nums = [str(x) for x in nums]
return ''.join(nums)
牛能和牛可樂的禮物
題目描述
衆所周知，牛能和牛可樂經常收到小粉絲們送來的禮物，每個禮物有特定的價值，他倆想要儘可能按照自己所得價值來平均分配所有禮物。
那麼問題來了，在最優的情況下，他倆手中得到的禮物價值和的最小差值是多少呢？
p.s 禮物都很珍貴，所以不可以拆開算哦
示例1
輸入
[1,2,3,4]
輸出
0
說明
他倆一個人拿1,4 。另一個人拿2,3
示例2
輸入
[1,3,5]
輸出
1
說明
他倆一個人拿1，3.另一個人拿5
備註:
單個禮物價值不超過100，禮物個數小於100，所有禮物總價值不超過10000
解法
01揹包的變形：體積和價值都是題目中給的“禮物價值”。
把總體積的一半作爲揹包容量，挨個判斷當前的禮物是否要放入到揹包。最後揹包中m體積所容納的就是最多的禮物。
#
#
# @param presentVec int整型一維數組 每個禮物的價值
# @return int整型
#
class Solution:
def maxPresent(self , presentVec ):
# write code here
n = len(presentVec)
m = int((sum(presentVec) + 1)/ 2)
dp = [0 for i in range(m + 1)]
for i in range(n):
for j in range(m, -1, -1):
if presentVec[i] > j:
continue
dp[j] = max(dp[j], dp[j - presentVec[i]] + presentVec[i])
a = dp[m]
b = sum(presentVec) - a
return abs(a - b)
牛妹的面試
題目描述
衆所周知，牛妹是一個offer收割姬，這次面試她遇到了這樣的一個問題。
給了一個序列，讓找出最長的“凸子序列”
何爲“凸子序列”：數列中有一個xi,使得所有x0<x1<x2….xi-1<xi且xi>xi+1>xi+1>….>xn
eg：12345431,是山峯序列，12345234不是山峯序列
注：單調遞增或單調遞減序列也算山峯序列；單獨一個數是長度爲1的山峯序列
示例1
輸入
[1,2,3,6,1]
輸出
5
示例2
輸入
[1,2,2,1]
輸出
3
說明
1,2,1
備註:
給定的序列中數都大於0 且不超過10000，且序列長度不超過1000
解法
開始想的是先求出列表中的最大值，那麼從最大值的位置分開，左右兩邊分別得到最長遞增序列的長度就可以了。後來發現這個會有很多邊界問題，處理起來比較麻煩。
從網上發現，其實就從左到右，從右到左分別得到兩個遞增序列的dp數組，然後在每個位置分別相加，得到的就是山峯長度。
#
# 返回最大山峯序列長度
# @param numberList int整型一維數組 給定的序列
# @return int整型
#
class Solution:
def mountainSequence(self , numberList ):
# write code here
if len(numberList) <= 1:
return len(numberList)
n = len(numberList)
res = 0
dp1 = self.dp_fuc(numberList)
dp2 = self.dp_fuc(numberList[::-1])
for i, x in enumerate(numberList):
tmp = dp1[i] + dp2[n - i - 1]
res = max(res, tmp)
return res - 1
def dp_fuc(self, sublist):
n = len(sublist)
if n == 0:
return 0
dp = [1] * n
for i in range(1, n):
for j in range(0, i):
if sublist[j] < sublist[i]:
dp[i] = max(dp[i], dp[j] + 1)
return dp
字符串距離計算
題目描述
給定兩個長度相等的，由小寫字母組成的字符串S1和S2，定義S1和S2的距離爲兩個字符串有多少個位置上的字母不相等。
現在牛牛可以選定兩個字母X1和X2，將S1中的所有字母X1均替換成X2。（X1和X2可以相同）
牛牛希望知道執行一次替換之後，兩個字符串的距離最少爲多少。
示例1
輸入
“aaa”,“bbb”
輸出
0
說明
牛牛可以將S1中的字符’a’全部替換成字符’b’，這樣S1就變成了"bbb"，那麼S1和S2的距離就是0
示例2
輸入
“aabb”,“cdef”
輸出
3
說明
一種可行的方案是將S1中的字符’a’全部替換成字符’c’，那麼S1變成了"ccbb"，和S2的距離是3
備註:
解法
參考標準題解：
對於所有可能的X1, X2, 記錄cnt[X1][X2]有多少個位置i, 使得S1[i] == X1, S2[i] == X2
這一步只需掃描一遍字符串即可計算得到
然後枚舉可能的X1, X2，這時距離 = 原本的距離 + cnt[X1][X1] - cnt[X1][X2]
時間複雜度O(N)
#
# 計算最少的距離
# @param S1 string字符串 第一個字符串
# @param S2 string字符串 第二個字符串
# @return int整型
#
class Solution:
def GetMinDistance(self , S1 , S2 ):
# write code here
cnt = [[0 for i in range(26)] for j in range(26)]
ans = 0
for i in range(len(S1)):
x, y = S1[i], S2[i]
xx, yy = ord(x) - ord('a'), ord(y) - ord('a')
cnt[xx][yy] += 1
if xx != yy:
ans += 1
res = ans
for i in range(26):
for j in range(26):
res = min(res, ans + cnt[i][i] - cnt[i][j])
return res
用兩個棧實現隊列
題目描述
用兩個棧來實現一個隊列，完成隊列的Push和Pop操作。 隊列中的元素爲int類型。
解法
開始沒怎麼看明白題目，所以看了題解。棧A用來作入隊列。棧B用來出隊列，當棧B爲空時，棧A全部出棧到棧B,棧B再出棧（即出隊列）。這個想法還是比較巧妙的。
# -*- coding:utf-8 -*-
class Solution:
def __init__(self):
self.stack1 = []
self.stack2 = []
def push(self, node):
# write code here
self.stack1.append(node)
def pop(self):
# return xx
if self.stack2 == []:
while self.stack1:
self.stack2.append(self.stack1.pop())
return self.stack2.pop()
旋轉數組的最小數字
題目描述
把一個數組最開始的若干個元素搬到數組的末尾，我們稱之爲數組的旋轉。
輸入一個非遞減排序的數組的一個旋轉，輸出旋轉數組的最小元素。
例如數組{3,4,5,1,2}爲{1,2,3,4,5}的一個旋轉，該數組的最小值爲1。
NOTE：給出的所有元素都大於0，若數組大小爲0，請返回0。
解法
其實就是用二分法。注意這裏面數組中可能會存在重複的數字，所以會有另外一個情況。
- mid值大於前一個值，直接輸出
- mid值大於left位置的值:說明我們需要找的值在mid的右邊，l=mid+1
- mid值小於left位置的值:說明我們需要找的值在mid的左邊，r=mid-1
- mid值等於left位置的值:此時無法判斷在左邊還是右邊，就縮小尋找的範圍，也就是left-=1;right-=1
# -*- coding:utf-8 -*-
class Solution:
def minNumberInRotateArray(self, rotateArray):
# write code here
if len(rotateArray) == 0:
return 0
l, r = 0, len(rotateArray) - 1
while l <= r:
mid = (l + r) // 2
if rotateArray[mid - 1] > rotateArray[mid]:
return rotateArray[mid]
elif rotateArray[l] < rotateArray[mid]:
l = mid + 1
elif rotateArray[l] > rotateArray[mid]:
r = mid - 1
else:
l -= 1
r -= 1
變態跳臺階
題目描述
一隻青蛙一次可以跳上1級臺階，也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
解法
使用數學歸納法，臺階爲n時，BT(n) = BT(n-1) + BT(n-2) + … + BT(1) + 1 = 2BT(n-1)
得到：當n>=1時，變態跳臺階的通式是:
BT(n) = 2BT(n-1) n>0
# -*- coding:utf-8 -*-
class Solution:
def jumpFloorII(self, number):
# write code here
if number == 1:
return 1
return 2 * self.jumpFloorII(number - 1)
另一種題目問法：
一隻青蛙一次可以跳上1級臺階，也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
思路：（斐波拉契數列）
當只有一級臺階時(n=1)，此時青蛙跳一次就可以完成目標；當只有兩級臺階時(n=2)，青蛙可以一次跳一級臺階分兩次完成也可以一次跳兩級臺階，此時有兩種跳法使得青蛙可以達成目標；
當n>2時，此時我們可以把n級臺階的跳法看成是n的函數:f(n)；如果青蛙第一步跳一級臺階，之後的跳法數目就是之後剩餘n-1級臺階的跳法數目，即f(n-1)；另一種可能的情況就是青蛙第一步跳兩級臺階，之後的跳法數目就是之後剩餘的n-2級臺階的跳法數目；所以n級臺階的不同跳法的總數是f(n)=f(n-1)+f(n-2)
不用加減乘除做加法
題目描述
寫一個函數，求兩個整數之和，要求在函數體內不得使用+、-、*、/四則運算符號。
解法
參考：https://zhuanlan.zhihu.com/p/112407870
因爲不允許採用四則運算，所以只能考慮位運算了。
其實就是用二進制來模擬加法操作。首先將兩個數最低位相加，如果都是 1，那麼就得到0，並且進位1，然後接着算下一位。
但是這樣一位一位模擬不方便實現，更簡單的實現方法是直接把兩個數對應位相加，不管進位。然後進位單獨計算，如果某一位兩個數都是1，那麼進位就會對下一位產生影響。然後接着算不進位求和加上進位的值，再計算新的進位，依次重複下去，直到進位爲0爲止。
用一個實際的例子來演示一下，計算3+7的值，其中s表示每一步不考慮進位的求和，c表示每一步的進位，最後得到結果，也就是十進制的10 ：
# -*- coding:utf-8 -*-
class Solution:
def Add(self, num1, num2):
# write code here
while num2 != 0:
temp = num1 ^ num2
num2 = (num1 & num2) << 1
num1 = temp & 0xFFFFFFFF
return num1 if num1 <= 0x7FFFFFFF else ~(num1 ^ 0xFFFFFFFF)
二叉樹的鏡像
題目描述
操作給定的二叉樹，將其變換爲源二叉樹的鏡像。
輸入描述:
解法
就直接遞歸的交換處理左右子樹就可以
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 返回鏡像樹的根節點
def Mirror(self, root):
# write code here
if root == None:
return root
root.left, root.right = root.right, root.left
root.left = self.Mirror(root.left)
root.right = self.Mirror(root.right)
return root
構建乘積數組
題目描述
給定一個數組A[0,1,…,n-1],請構建一個數組B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。（注意：規定B[0] = A[1] * A[2] * … * A[n-1]，B[n-1] = A[0] * A[1] * … * A[n-2];）
解法
其實就是提前準備好兩個全乘好的數組，然後再從左到右過一遍A，得到對應位置上兩個數組的乘積。
# -*- coding:utf-8 -*-
class Solution:
def multiply(self, A):
# write code here
l, r = [], []
n = len(A)
tmp = 1
l.append(tmp)
for i, x in enumerate(A):
tmp *= x
l.append(tmp)
tmp = 1
for i in range(len(A)-1, -1, -1):
tmp *= A[i]
r.append(tmp)
r.append(1)
res = []
for i in range(len(A)):
tmp = l[i] * r[n - i - 2]
res.append(tmp)
return res
連續子數組的最大和
題目描述
HZ偶爾會拿些專業問題來忽悠那些非計算機專業的同學。今天測試組開完會後,他又發話了:在古老的一維模式識別中,常常需要計算連續子向量的最大和,當向量全爲正數的時候,問題很好解決。但是,如果向量中包含負數,是否應該包含某個負數,並期望旁邊的正數會彌補它呢？例如:{6,-3,-2,7,-15,1,2,2},連續子向量的最大和爲8(從第0個開始,到第3個爲止)。給一個數組，返回它的最大連續子序列的和，你會不會被他忽悠住？(子向量的長度至少是1)
解法
就是簡單的動態規劃
# -*- coding:utf-8 -*-
class Solution:
def FindGreatestSumOfSubArray(self, array):
# write code here
dp = [0] * len(array)
for i, x in enumerate(array):
if i == 0:
dp[i] = x
ma = x
dp[i] = max(x, dp[i - 1] + x)
if dp[i] > ma:
ma = dp[i]
return ma
跳臺階
題目描述
一隻青蛙一次可以跳上1級臺階，也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法（先後次序不同算不同的結果）。
解法
就是斐波那契數列，但是如果直接遞歸會超時，所以迭代。
# -*- coding:utf-8 -*-
class Solution:
def jumpFloor(self, number):
# write code here
res = []
for i in range(1, number + 1):
if i in [0, 1, 2]:
res.append(i)
else:
res.append(res[-1] + res[-2])
return res[-1]
'''
if number in [0, 1, 2]:
return number
return self.jumpFloor(number - 1) + self.jumpFloor(number - 2)
'''
矩形覆蓋
我們可以用21的小矩形橫着或者豎着去覆蓋更大的矩形。請問用n個21的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？
比如n=3時，2*3的矩形塊有3種覆蓋方法
解法
和上面的題一樣，不過這個要找規律，可以發現n=0, f=0; n=1, f=1; n=2, f=2; n=3, f=3; n=4; f=5… 就比如n=4的時候，其中3個可以在n=3的情況下加上一個豎着的，另外2個就是在n=2的情況下加上兩個橫着的。
# -*- coding:utf-8 -*-
class Solution:
def rectCover(self, number):
# write code here
res = []
for i in range(0, number + 1):
if i in [0, 1, 2]:
res.append(i)
else:
res.append(res[-1] + res[-2])
return res[-1]
平衡二叉樹
題目描述
輸入一棵二叉樹，判斷該二叉樹是否是平衡二叉樹。
在這裏，我們只需要考慮其平衡性，不需要考慮其是不是排序二叉樹
解法
在二叉搜索樹那塊也做過這個題，就是兩個遞歸調用，一次是求深度，一次是求子樹是否平衡。問題是求深度那個遞歸需要調用好幾次，而且其中可能會有些重複計算。
所以可以用自底向上的方法來求，利用後序遍歷：左子樹、右子樹、根節點,可以先遞歸到葉子節點，然後在回溯的過程中來判斷是否滿足條件。
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def depth(self, root):
if not root:
return 0
return max(self.depth(root.left), self.depth(root.right)) + 1
def IsBalanced_Solution(self, pRoot):
# write code here
if not pRoot:
return True
if abs(self.depth(pRoot.left) - self.depth(pRoot.right)) > 1:
return False
return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
方法2：
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def depth(self, root):
if not root:
return 0
l = self.depth(root.left)
if l == -1:
return -1
r = self.depth(root.right)
if r == -1:
return -1
if abs(l - r) > 1:
return -1
return max(l, r) + 1
def IsBalanced_Solution(self, pRoot):
# write code here
if not pRoot:
return True
if self.depth(pRoot) == -1:
return False
return True
二進制中1的個數
輸入一個整數，輸出該數二進制表示中1的個數。其中負數用補碼錶示。
解法
第一種，可以將n上的每一位與1取與，統計1的個數；在求解的過程中每次循環時1左移一位，即n<<1
第二種，如果一個整數不爲0，那麼這個整數至少有一位是1。如果我們把這個整數減1，那麼原來處在整數最右邊的1就會變爲0，原來在1後面的所有的0都會變成1(如果最右邊的1後面還有0的話)。其餘所有位將不會受到影響。
舉個例子：一個二進制數1100，從右邊數起第三位是處於最右邊的一個1。減去1後，第三位變成0，它後面的兩位0變成了1，而前面的1保持不變，因此得到的結果是1011.我們發現減1的結果是把最右邊的一個1開始的所有位都取反了。這個時候如果我們再把原來的整數和減去1之後的結果做與運算，從原來整數最右邊一個1那一位開始所有位都會變成0。如1100&1011=1000.也就是說，把一個整數減去1，再和原整數做與運算，會把該整數最右邊一個1變成0.那麼一個整數的二進制有多少個1，就可以進行多少次這樣的操作。
# -*- coding:utf-8 -*-
class Solution:
def NumberOf1(self, n):
# write code here
if n < 0:
n = n & 0xffffffff
res = 0
while n != 0:
n = n & (n - 1)
res += 1
return res
兩個鏈表的第一個公共節點
輸入兩個鏈表，找出它們的第一個公共結點。（注意因爲傳入數據是鏈表，所以錯誤測試數據的提示是用其他方式顯示的，保證傳入數據是正確的）
解法
就是首先構造出相同長度的鏈表，這樣的話就用雙指針同時在兩個鏈表遍歷肯定會有公共節點了。
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def FindFirstCommonNode(self, pHead1, pHead2):
# write code here
l1, l2 = 0, 0
cur1 = pHead1
while cur1:
l1 += 1
cur1 = cur1.next
cur2 = pHead2
while cur2:
l2 += 1
cur2 = cur2.next
tmp = abs(l1 - l2)
if l1 > l2:
while tmp > 0:
pHead1 = pHead1.next
tmp -= 1
else:
while tmp > 0:
pHead2 = pHead2.next
tmp -= 1
while pHead1 and pHead2:
if pHead1 == pHead2:
return pHead1
pHead1 = pHead1.next
pHead2 = pHead2.next
數值的整數次方
給定一個double類型的浮點數base和int類型的整數exponent。求base的exponent次方。
保證base和exponent不同時爲0
解法
參考：https://www.nowcoder.com/questionTerminal/1a834e5e3e1a4b7ba251417554e07c00?answerType=1&f=discussion
首先做預處理：求pow(b, n)，如果n爲負數怎麼解決
然後是兩種方法：
- 直接暴力循環n次求解
- 快速冪的遞歸法求解，注意處理奇偶情況
# -*- coding:utf-8 -*-
class Solution:
def Power(self, base, exponent):
# write code here
if exponent == 0:
return 1.0
if exponent < 0:
base = 1 / base
exponent = -exponent
tmp = self.Power(base, exponent/2)
if exponent % 2 == 0:
res = tmp * tmp
else:
res = tmp * tmp * base
return res