幾個有趣的算法題目
本文首發 http://svtter.cnpython
最接近的數字
題目
一個K位的數N算法
$$ (K\leq2000，N\leq10^{20}) $$編程
找出一個比N大且最接近的數，這個數的每位之和與N相同，用代碼實現之。數組
例如：0050 所求書數字爲0104；112 所求數爲121；app
算法分析 算法思想
直接暴力求這個數字是不能夠的，數字的量級太大，有K位的數字，不可能直接用int，或者float來表示，使用數組來存儲。應該分析這個數字，step1，從右邊開始的最小位數開始，分解最後一位數字，分解出1來拿給前面的一位。9和0比較特殊，所以從左往右掃描的開始，遇到0就跳過，遇到第一個非0的數字，就把這個數字-1，而後移到最後面去，而後，step2，開始找第一個非9的數字，若是遇到9，就把9放到最後面去，遇到非9，就+1，結束運算。dom
一個般的例子：ide
1999000 -> 1990008-> 2000899函數
要注意一個問題，就是若是是 999000 這種狀況，在數字的最開頭補1，結果是1000899測試
幾個刁蠻的數據：29399 -> 29489優化
僞代碼
array = get_array() # number to char array
array.reverse()
step1 = true
step2 = false
zero = 0, cnt = 0;
for i : 1 - lengthof(array)
if step1:
if array[i] is 0:
zero ++
else:
array[i] = array[i] - 1
if zero > 0:
array[0] = array[i]
array[i] = 0
step1 = false
step2 = true
else if step2:
if array[i] is 9:
if zero == 0:
array[cnt+1] = array[cnt]
array[cnt] = 9
cnt++
if (i != cnt):
array[i] = array[i-1]
else:
array[cnt + 1] = array[cnt]
array[cnt] = 9
cnt++
array[i] = 0
else:
i = i+1
step2 = false
break
if not step2:
array[lengthof(array)] = 1
array.reverse()
disp(array)
分析時間複雜度O
由於reverse操做，2K，加上最後整理最小數到最前面，最壞狀況接近K，3K，在循環中的操做看運氣，可是最糟糕的狀況也只有5K，因此時間複雜度爲
$$ O(3K) \approx O(K) $$
源代碼
#include <stdio.h>
#include <string.h>
const int MAXN = 3000;
char array[MAXN];
int length_of_number;
void get_array()
{
int i;
char null;
scanf("%d", &length_of_number);
scanf("%c", &null);
for (i = 0; i < length_of_number; i++)
{
scanf("%c", &array[i]);
}
scanf("%c", &null);
}
void reverse()
{
int i ;
char temp;
for (i = 0; i < length_of_number/2; i++)
{
// _swap
temp = array[i];
array[i] = array[length_of_number - 1 - i];
array[length_of_number-1-i] = temp;
}
}
void run()
{
reverse();
int step1 = 1,
step2 = 0,
i = 0,
zero = 0,
cnt = 0;
for (i = 0; i < length_of_number; i++)
{
if (step1)
{
if (array[i] == '0')
{
zero++;
}
else
{
array[i] = array[i] - 1;
if (zero > 0)
{
array[cnt] = array[i];
array[i] = '0';
}
step1 = 0, step2 = 1;
}
}
else if (step2)
{
if (array[i] == '9')
{
if (zero == 0)
{
array[cnt + 1] = array[cnt];
array[cnt] = '9';
cnt++;
if (i != cnt)
{
array[i] = array[i-1];
}
}
else
{
array[cnt + 1] = array[cnt];
array[cnt] = '9';
cnt++;
array[i] = '0';
}
}
else
{
array[i] ++;
step2 = 0;
break;
}
}
}
if (step2)
{
array[length_of_number] = '1';
length_of_number ++;
}
}
void output()
{
int i;
reverse();
for(i = 0; i < length_of_number; i++)
{
printf("%c", array[i]);
}
printf("\n");
}
int main()
{
memset(array, 0, sizeof(array));
freopen("input", "r", stdin);
get_array();
run();
output();
return 0;
}
測試結果
使用python生成測試數據進行測試：
"""
最接近的數字
"""
import random
import os
def test():
"""
sample test
"""
num = random.randint(0, 10000000)
sum_of_num = 0
for i in str(num):
sum_of_num += int(i)
length = len(str(num))
temp_num = num + 1
while(True):
sum_temp = 0
for i in str(temp_num):
sum_temp += int(i)
if sum_temp == sum_of_num:
break
temp_num += 1
with open('input', 'w') as f:
f.write(str(length) + '\n')
f.write(str(num))
res = os.popen('./ex2').read()
if temp_num == int(res):
return [True]
else:
return [False, num, temp_num, int(res)]
all = True
for i in range(1000):
res = test()
if res[0] is False:
all = False
print(res)
if all:
print('Pass testing!')
存在錯誤的狀況：
經過：
後期改善優化的地方
reverse 是爲了編程方便進行的處理，可是若是數字太大，速度確定會受影響，這個時候就不要使用reverse了。
用鏈表來作能夠簡化代碼，減小分析的，更加節省時間
處理移位的時候考慮幾個問題
尋找發帖水王
題目
若是「水王」沒有了，但有三個發帖不少的ID，發帖的數目都超過了帖子作數的1/4，又如何快速找出他們的ID。
算法分析 算法思想
從0-n掃描ID數組，記錄3個數字的個數，若是出現第四個數字，就把三個數字的個數減小1，若是有一個數字的個數減小到0，那麼把新來的數字做爲本來三個數字之一進行記錄。
如此一來，掃描完ID數組以後，剩下記錄的3個數字的個數即是須要求的三個數字。
僞代碼
array = get_array()
count = empty_set()
for i in array:
if count.full:
if i in count:
count.i.num ++
else:
for j in count:
count.j.num--
else
count.add(i)
disp(count)
分析時間複雜度O
數列的大小爲N，記錄數字的數組大小爲3，每次判斷記錄數組count是否存在0，以及找到已存在的數字++，都會花費3個單位時間，所以其時間複雜度爲
$$ O(3n) \approx O(n) $$
源代碼
#include <stdio.h>
#include <string.h>
#define MAXN 5000
int idarray[MAXN];
int cur[3]; // 記錄當前元素
int pos[3]; // 記錄當前元素個數
// 檢查是否在數組內，若是不在數組內，添加進入數組
void checkin(int no)
{
int i;
// 檢查是否有空位置
for (i = 0; i < 3; i++)
{
if (pos[i] == 0)
{
cur[i] = no;
pos[i] ++;
return;
}
}
// 尋找指定數字++
for (i = 0; i < 3; i++)
{
if (cur[i] == no)
{
pos[i] ++;
return;
}
}
// 沒有找到重複數字，所有--
for (i = 0; i < 3; i++)
pos[i] --;
}
// 輸出最後結果
void output()
{
printf("%d %d %d\n", cur[0], cur[1], cur[2]);
}
// 主程序
int numberOfArray;
void run()
{
int i;
for (i = 0; i < numberOfArray; i++)
{
checkin(idarray[i]);
}
output();
}
void input()
{
int i;
scanf("%d", &numberOfArray);
for(i = 0; i < numberOfArray; i++)
{
scanf("%d", &idarray[i]);
}
}
int main()
{
freopen("input", "r", stdin);
int groupOfTest;
scanf("%d", &groupOfTest);
while(groupOfTest--)
{
memset(cur, 0, sizeof(cur));
memset(pos, 0, sizeof(pos));
memset(idarray, 0, sizeof(idarray));
input();
puts("Test running...");
run();
}
return 0;
}
測試結果
本測試數據採用Python自動生成。
"""
尋找發帖水王
"""
import random
N = 4000
a, b = (int(N/4), int(N/3))
three_id = random.sample(range(1, 100), 3)
three_id_num = {}
sum_rand = 0
for i in three_id:
temp = random.randint(a, b)
sum_rand += temp
three_id_num[i] = three_id_num.get(i, 0) + temp
id_array = [random.randint(1, 100) for i in range(N-sum_rand)]
for i in three_id:
id_array = id_array + [i for j in range(three_id_num[i])]
random.shuffle(id_array)
print('Most three id:', three_id)
print('Three id num: ', three_id_num)
print('Sum of three_id num: ', sum_rand)
print('---------------')
# print(id_array)
with open('input', 'w') as f:
f.write('1\n')
f.write(str(N) + '\n')
for i in id_array:
f.write(str(i) + ' ')
後期改善優化的地方
對於N比較小的狀況能夠在內存中進行查找，可是一旦涉及到更大的數據，這個方法可能就沒有那麼簡單了，不能在內部創建數組，須要一部分一部分的從磁盤中讀數；
若是須要查找的id數量變多，那麼須要的臨時保存的數列可能更大；
這個實現沒有使用STL中的map，若是使用map，還能進一步使得代碼看法易懂，map使用hash來作內部實現，可使得面對數據量更大的數據的時候，加快查找數據的速度。
山西煤老闆
題目
你是山西的一個煤老闆，你在礦區開採了有3000噸煤須要運送到市場上去賣，從你的礦區到市場有1000千米，你手裏有一列燒煤的火車，這個火車只能裝1000噸煤，且能耗比較大——每一千米須要耗一噸煤。請問，做爲一個懂編程的煤老闆，你會怎麼運送才能運最多的煤到集市？
算法分析 算法思想
從動態規劃的角度求最優解：
假設起始運送貨物量爲t，終點路程爲s，火車容量爲c，能夠運抵終點的最多貨物量爲函數 F(t, s)。
3種基本狀況：
（1）t < s：貨物量不足以運送到此距離，因此F(t, s) = 0;
（2）s < t < c：火車一次就能夠裝完貨物，因此F(t, s) = t - s;
（3）2s < c 使得火車一次沒法運完，但能夠採用往返的方式屢次運輸，這種狀況下最有的方式就是減小總共往返的次數，也就是直接運到終點而不在中間卸貨，因此
$$ F(t, s) = (t / c - 1) * (c - 2s) + (c - s) $$
可得遞歸式：
$$ F(t, s) = max\{ F( F(t, i), s - i)\} (1 <= i < s) $$
分析了一下這個方程是有問題的，好比F(1750, 250)會計算出1125；
因此正確的結果應該對t/c進行處理，也就是說，起點剩餘的燃料不足運輸到終點，直接捨棄。第三階段的方程式應該是
$$ F(t, s) = (t // c - 1) * (c - 2s) + (c - s) + (t \% c - 2 s), if (t\%c > 2s) $$
僞代碼
begin:
if t < s:
f[t][s] = 0
elif s < t < c:
f[t][s] = t - s
elif 2*s < c:
f[t][s] = int((t//c-1)*(c-2*s) + (c-s))
if t % c > 2*s:
f[t][s] += int(t % c-2*s)
else:
pre = -2
for i in range(1, s):
pre = int(max(F(F(t, i), s-i), pre))
f[t][s] = pre
end
disp(f[3000][1000])
分析時間複雜度O
時間複雜度爲
$$ O(3000*3000) $$
由於每一個數字都要計算一遍。
源代碼
"""
山西煤老闆
"""
c = 1000
f = [[-1 for k in range(4000)] for j in range(4000)]
for j in range(4000):
for k in range(4000):
if j < k:
f[j][k] = 0
count = 1000
cnt = 0
def F(t, s):
"""
dp
"""
global count
global c
global f
# count -= 1
# if count == 0:
# count = int(input())
t = int(t)
s = int(s)
if f[t][s] != -1:
return f[t][s]
if t < s:
f[t][s] = 0
elif s < t < c:
f[t][s] = t - s
elif 2*s < c:
f[t][s] = int((t//c-1)*(c-2*s) + (c-s))
if t % c > 2*s:
f[t][s] += int(t % c-2*s)
else:
pre = -2
for i in range(1, s):
pre = int(max(F(F(t, i), s-i), pre))
f[t][s] = pre
print(t, s, f[t][s])
return f[t][s]
print(F(3000, 500))
測試結果
後期改善優化的地方
去除了一下數據進行加速
保存f減小重複運算值
-
應該有更加簡單的方法，相似這種，可是很差解釋。
$$ 3y=1000\\ 5x=1000\\ 解得x+y=200+333=533，所以使得最後一輛火車抵達時節省了533噸煤\\ $$
題目
Given a list of words, L, that are all the same length, and a string, S, find the starting position of the substring of S that is concatenation of each word in L exactly once and without intervening characters. This substring will occur exactly once in S.
算法分析 算法思想
使用hashmap來保存word的hash值，來加快查找速度。（舊）
直接用hash函數求字符串的hash值，最後求得結果。
依據公式
$$ hash(w_1) + hash(w_2) = hash(w_2) + hash(w_1) $$
僞代碼
hash_word_list = list(map(hash, words))
hash_sum = reduce(lambda x, y: x + y, hash_word_list)
for i in range(len(sentence)):
wl = word_len
wlist = [sentence[i+j*wl:i+j*wl+wl] for j in range(words_len)]
temp_sum = 0
for k in wlist:
temp_sum += hash(k)
if temp_sum == hash_sum:
print(i)
break
分析時間複雜度O
就是字符串長度
$$ O(lengthOfS) $$
源代碼
#!/usr/bin/env python3
"""
facebook
"""
from functools import reduce
while True:
words = input()
# words = "fooo barr wing ding wing"
words = words.split(' ')
word_len = len(words[0])
words_len = len(words)
hash_word_list = list(map(hash, words))
hash_sum = reduce(lambda x, y: x + y, hash_word_list)
sentence = input()
# sentence = """lingmindraboofooowingdin\
# gbarrwingfooomonkeypoundcakewingdingbarrwingfooowing"""
# print(words, words_len, word_len, sentence)
for i in range(len(sentence)):
wl = word_len
wlist = [sentence[i+j*wl:i+j*wl+wl] for j in range(words_len)]
# print(wlist)
temp_sum = 0
for k in wlist:
temp_sum += hash(k)
if temp_sum == hash_sum:
print(i)
break
測試結果
測試數據生成意義不是很大，
後期改善優化的地方
hash儘管在速度上很是優秀，可是在準確度方面，若是出現hash衝突，那麼值可能不許確。此時能夠利用hashmap來解決這個問題，不過會多出重置hashmap的相關時間。
For n -m - problems
Problemset
Assume we have a sequence that contains N numbers of type long. And we know for sure that among this sequence each number does occur exactly n times except for the one number that occurs exactly m times (0 < m < n). How do we find that number with O(N) operations and O(1) additional memory?
Algorithm
^ is the add operation without carry.
默認one,two都是0, 即任何數字都不存在
數字a第一次來的時候, one標記a存在, two不變
數字a第二次來的時候, one標記a不存在, two標記a存在
數字a第三次來的時候, one不變, two標記a不存在
構造這樣一種運算，經過異或將數據保存在one和two裏面。
Pseudocode
def solve2(array):
one = 0, two = 0
for i in range(array):
one = (one ^ array[i]) & ~two
two = (two ^ array[i]) & ~one
return one, two
array = input()
_, res = solve2(array)
### Source code
#!/usr/bin/env python
def solve(array):
one, two = 0, 0
for i in array:
one = (one ^ i) & ~two
two = (two ^ i) & ~one
return one, two
if __name__ == '__main__':
array = input()
array = array.split(' ')
array = list(map(lambda x: int(x), array))
# print(array)
_, res = solve(array)
print(res)
Test
#!/usr/bin/env python3
import random
def test():
"""
測試
"""
array = []
n, m = 3, 2
numberofNum = random.randint(100, 1000)
record = {}
for _ in range(numberofNum):
temp = random.randint(10, 10000)
while temp in record:
temp = random.randint(10, 10000)
record[temp] = 1
for _ in range(3):
array.append(temp)
temp = random.randint(10, 1000)
while temp in record:
temp = random.randint(10, 1000)
array.append(temp)
array.append(temp)
from run import solve
_, res = solve(array)
if res != temp:
print('ERROR')
print(array, temp)
input()
else:
print('Pass: res: ', res, 'temp:', temp)
for i in range(50):
test()
Use python generate data to test.
Discussion and improve
若是n不是3，那麼須要構造更多的臨時變量。
很長的數組
題目
一個很長很長的short型數組A，將它分紅m個長爲L的子數組B1，B2，…，Bm，其中每一個數組排序後都是遞增的等差數列，求最大的L值。
$$ 例如，A = \{-1, 3, 6, 1, 8, 10\} 能夠分紅B_1 = \{-1, 1, 3\}, B_2 = \{6, 8, 10\},\; L = 3 即爲所求。 $$
算法分析
首先進行排序，而後開始分三步走。
統計元素個數 O(n)
-
排序 O(nlog(n))
第一步用來枚舉L和m的大小，由題目可知，L * m = 數組的長度。從m爲1開始枚舉，保證獲得的L爲最大值。
第二步搜索爲深搜，肯定當前子數組的起點和初始步長，使用pos記錄當前數組選定的元素。
第三步枚舉，根據起點給定的初始步長，開始枚舉步長，若是枚舉的步長能夠在數組中找到足夠的元素，即數字爲L，那麼記錄這種分法，開始枚舉下一個起點。若是枚舉的步長和起點沒法知足條件，回溯到上一個節點，把上一個節點記錄的步長+1再一次搜索。當枚舉的起點數達到m，即知足要求輸出。
大白話來說，就是從頭開始分原始數組到m個數組中去，排序事後，在前面的每個節點未被分配的元素，都是子數組起點。若是使用廣度優先搜索，即每次都給一個子數組分配一個知足子數組步長要求的數，會致使在最後才發現分配的元素數不知足要求，從而浪費大量時間。
其中，深度優先搜索還有幾個剪枝的技巧：
當前步長*(L-1)若是超過了數組的最大元素，能夠不繼續搜索
-
若是在給定步長的狀況下， 下一個數字的大小超過以前的數字+步長，那麼能夠沒必要繼續搜索。
由於數組已經排好序。
還有其餘的剪枝技巧，體如今代碼中了。
時間複雜度
n爲數組長度，排序的時間爲 O(nlogn)，枚舉m時間爲n，枚舉step時間爲65536【short跨度】，枚舉所有元素時間爲n，所以算法的時間上界爲
$$ O(65536n^2) $$
實際狀況下，因爲剪枝等操做的存在，應優於這個時間。
僞代碼
leng = len(Array)
for m=1 to n:
if n % m != 0:
continue
L = n // m
# deep search
res, record = findArray(L, m)
def findArray(L, m):
group = 0
pos = np.ones(leng)
record = []
record_start = []
while group != m:
step = 0
start = getStart(pos)
res, step = 尋找合適的步長(start, step, pos, record, L)
if res:
找到了計數
while res is False:
沒找到彈出棧，往回找
if 彈出棧爲空:
不用找了找不到了
return False, None
源代碼
#!/usr/bin/env python3
# coding: utf-8
"""
arrays
"""
from __future__ import print_function
import numpy as np
array = [-1, 3, 6, 1, 8, 10]
# array = [1, 5, 9, 2, 6, 10]
# array = [1, 2, 4, 5, 8, 9, 13, 14]
# array = [1, 2, 4, 7, 11]
array = sorted(array)
print(array)
leng = len(array)
maxn = array[leng-1]
enable = 1
disable = 0
def findJ(j, step, pos, record, L):
"""
尋找以J爲開始，以步長step爲開始的數列
"""
class StepError(Exception):
pass
class MaxException(Exception):
pass
if pos[j] == disable:
return False
start = array[j]
pre = start
record_temp = []
# remember zero
try:
for step in range(step, 40000):
# 把第一個數字記錄
record_temp.append(j)
pos[j] = disable
pre = start
if start + step * (L - 1) > maxn:
raise MaxException
try:
cnt = 1
if cnt == L:
record.append(record_temp)
return True, step
for k in range(j, leng):
if pos[k] == disable:
continue
elif pos[k] == enable and array[k] == pre + step:
record_temp.append(k)
pre = array[k]
cnt += 1
pos[k] = disable
elif pos[k] == enable and array[k] > pre + step:
raise StepError
if cnt == L:
record.append(record_temp)
return True, step
except StepError:
# 重置標記
for r in record_temp:
pos[r] = enable
record_temp = []
except MaxException:
# 沒有合適的step
return False, None
def findArray(L, m):
"""
尋找數組
"""
pos = np.ones(leng)
record = []
record_start = []
group = 0
while group != m:
start = 0
while pos[start] == disable:
start += 1
step = 0
res, step = findJ(start, step, pos, record, L)
if res:
group += 1
record_start.append((start, step))
while res is False:
try:
start, step = record_start.pop()
for r in record.pop():
pos[r] = enable
group -= 1
res, step = findJ(start, step+1, pos, record, L)
except IndexError:
return False, None
return True, record
def divideArray():
"""
分離數組
m 是分離的數組的個數
L 是分離的數組的長度
"""
for m in range(1, leng+1):
if leng % m != 0:
continue
L = leng // m
res, record = findArray(L, m)
def trans(x):
return array[x]
if res:
print('lenth: ', L)
for r in record:
temp = map(trans, r)
print(list(temp))
return
print('No result.')
if __name__ == '__main__':
divideArray()
測試
測試樣例生成結果未必準確，找了部分的測試樣例，能夠經過修改代碼中array來提現。
討論
在記錄了起點和步長，應該能夠利用這兩點推出當前使用了哪些元素，若是空間大小不夠使用，能夠不適用record記錄，若是下一層不知足條件回溯的時候，能夠利用起點和步長回推已經使用的元素。
- 1. 幾個有趣的算法題目
- 2. 幾個有趣的問題？
- 3. 有趣的算法題目集錦
- 4. 最近star的幾個有趣項目
- 5. 一個有趣的機率問題
- 6. 一個有趣的幾何問題
- 7. Object有趣的幾個方法
- 8. 幾個有意思的算法題
- 9. 有趣的算法
- 10. 一些有趣的算法題
- 更多相關文章...
- • Markdown 標題 - Markdown 教程
- • jQuery Mobile 主題 - jQuery Mobile 教程
- • 算法總結-廣度優先算法
- • 算法總結-深度優先算法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. eclipse設置粘貼字符串自動轉義
- 2. android客戶端學習-啓動模擬器異常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout問題
- 4. MYSQL8.0數據庫恢復 MYSQL8.0ibd數據恢復 MYSQL8.0恢復數據庫
- 5. 你本是一個肉體，是什麼驅使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一個肉體，是什麼驅使你前行【3】
- 9. 你本是一個肉體，是什麼驅使你前行【2】
- 10. 【資訊】LocalBitcoins達到每週交易比特幣的7年低點
- 1. 幾個有趣的算法題目
- 2. 幾個有趣的問題？
- 3. 有趣的算法題目集錦
- 4. 最近star的幾個有趣項目
- 5. 一個有趣的機率問題
- 6. 一個有趣的幾何問題
- 7. Object有趣的幾個方法
- 8. 幾個有意思的算法題
- 9. 有趣的算法
- 10. 一些有趣的算法題