題目1
題目鏈接
題目大意：
在二維坐標系上，小明站在原點（0，0），每次可以往上下左右四個方向分別位移1個單位；
現在有n個點，小明需要去遍歷；
但是4個方向對應的按鈕，小明最多只能按3個，如果4個方向的按鈕全部按過，則直接失敗。
問小明是否能夠順利完成。
輸入：
第一行，整數?? 表示t個樣例 ?? (1≤??≤10000)
每個樣例第一行，整數 ?? (1≤??≤100)
接下來n行整數，每行2個整數表示目標點 ???? , ???? (?100≤????,????≤100 )
輸出：
每個樣例一行，如果可以成功則輸出YES，如果失敗則輸出NO；
Examples
input
6
3
1 -1
0 0
1 -1
4
-3 -2
-3 -1
-3 0
-3 1
4
1 1
-1 -1
1 -1
-1 1
6
-4 14
-9 -13
-14 5
14 15
-8 -4
19 9
6
82 64
39 91
3 46
87 83
74 21
7 25
1
100 -100
output
YES
YES
NO
NO
YES
YES
題目解析：
假設只能向上、向右走，那么小明可以訪問到第一象限上面的點，但是可以遍歷到所有點嗎？
假設第一象限上，有四個點組成一個正方形，小明必然會有對角線的點無法訪問。
同理，小明站在原點上，將n個點分配到四個象限。
當存在對角象限同時存在點時，必然無解。比如說（1，1）和（-1，-1），須要用到4個方向。
但是這個象限處理方式，在遇到0時，比較難以處理。
重新思考題目，其實4個方向，就是分別對應x坐標的正負，y坐標的正負。
那么假設所有的點，對應到x坐標，如果沒有小于零，那么對應按鈕↓可以不用。
class Solution {
static const int N = 201010;
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[2] = {0}, b[2] = {0};
while (n--) {
int x, y;
cin >> x >> y;
if (x != 0) a[x > 0 ? 0:1] = 1;
if (y != 0) b[y > 0 ? 0:1] = 1;
}
if (a[0] + a[1] + b[0] + b[1] < 4) cout << "YES" << endl;
else cout << "NO" << endl;
}
}
}
ac;
題目2
題目鏈接
題目大意：
有n個整數的數組a，數組中每個元素互不相同；
現在可以選擇一個數字k，將數組中每一個元素進行對k取余的操作，然后將余數替代原來的元素；
要求選擇一個整數k，使得數組在操作后所有元素有且僅有2個不同的值。
輸入：
第一行，整數?? 表示t個樣例 ?? (1≤??≤500)
每個樣例
第一行，整數 ?? (1≤??≤100)
第二行，n個整數??1,??2,…,????(1≤????≤1e17)
輸出：
每個樣例一行，輸出滿足要求的 ?? (1≤??≤1e18 )，題目保證有解；
Examples
input
5
4
8 15 22 30
5
60 90 98 120 308
6
328 769 541 986 215 734
5
1000 2000 7000 11000 16000
2
2 1
output
7
30
3
5000
1000000000000000000
題目解析：
由于題目要求最后的余數有且僅有兩個數字，而取余之后有2個余數的情況，自然就能想到k=2。
我們對題目整數的值進行分類討論：
1、元素如果有奇數和偶數，%2就有0和1；
2、如果全是偶數，也就是都是2 * x，那么可以再考慮k=4、8、16以此類推；
3、如果全是奇數，假如1、3、5、7，%2全部是1，那么%4呢？首先排除0和2，因為都是奇數，不會產生偶數；那么結果只有2種情況，要么是1，要么3；
那么假如全部是3呢？比如說3，7，11呢？那么必然全部可以抽象成4 x k + 3。可以繼續用8來取余。轉化為k為奇數或者偶數。
class Solution {
static const int N = 201010;
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<lld> a;
for (int i = 0; i < n; ++i) {
lld x;
cin >> x;
a.push_back(x);
}
lld ans = 2;
do {
map<lld, int> h;
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (!h[a[i] % ans]) {
h[a[i] % ans] = 1;
++cnt;
}
}
if (cnt > 1) break;
} while (ans *= 2);
cout<< ans << endl;
}
}
}
ac;
題目3
題目鏈接
題目大意：
有n個整數的數組a，我們定義區間[l, r]的區間和為相鄰元素的絕對值之和，用數學定義來表示：
??(??,??)=|??[??] ? ??[??+1]| + |??[??+1] ? ??[??+2]| + … + |??[???1] ? ??[??]|.
如果區間長度為1，則區間和為0。
現在需要將數組分隔成k個連續子數組，保證元素的相對順序不變；
現在想知道，分隔完之后所有數組進行區間和，總和最小為多少？
輸入：
第一行，整數?? 表示t個樣例 ?? (1≤??≤100)
每個樣例兩行
第一行整數??,?? (1≤??≤??≤100 ).
第二行整數??1,??2,…,????(1≤????≤500)
輸出：
每個樣例，輸出最小的區間和。
Examples
input
3
4 2
1 3 5 2
6 3
1 9 12 4 7 2
12 8
1 9 8 2 3 3 1 8 7 7 9 2
output
4
11
2
題目解析：
兩個分析思路。
1、n的思考角度，從重復子問題來看，dp[i][j]表示前i個數字分隔成j段的最小值，那么dp[i][j]就可以由dp[i-1][j]和dp[1~i-1][j-1]來轉移；
2、k的思考角度，k=1時可以直接計算，k=2時我們會選擇一個相鄰絕對值最大值去分開，k=3時就是選擇前2個相鄰絕對值最大值去分開。
兩個思路都可以解決問題，但是思路2的實現難度要低很多。
class Solution {
static const int N = 201010;
int a[N];
int b[N];
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n - 1; ++i) b[i] = abs(a[i] - a[i+1]);
sort(b, b + n - 1);
int sum = 0;
for (int i = 0; i < n - k; ++i) sum += b[i];
cout << sum << endl;
}
}
}
ac;
題目4
題目鏈接
題目大意：
輸入：
第一行，整數?? 表示t個樣例 ?? (1≤??≤100)
每個樣例兩行
第一行整數??,?? (1≤??≤??≤100 ).
第二行整數??1,??2,…,????(1≤????≤500)
輸出：
每個樣例，輸出最小的區間和。
Examples
input
3
4 2
1 3 5 2
6 3
1 9 12 4 7 2
12 8
1 9 8 2 3 3 1 8 7 7 9 2
output
4
11
2
題目解析：
n=1時，最小值就是a[1];
n=2時，最小值就是a[1]&a[2];
n=k時，最小值就是a[1]~a[k]的與，因為and操作只會使得結果更小；
假設最小值結果為m；
m不為0時，集合數量只能為1，因為拆分兩個集合結果就變成2m，值會更大；
m為0時，集合數量可以拆分為多個&值為0的區間，那么從左到右遍歷，累計出現&結果為0就算一個區間。
class Solution {
static const int N = 201010;
static const int inf = 0x7fffffff;
int a[N];
int b[N];
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
int m = a[0];
for (int i = 1; i < n; ++i) m = m&a[i];
if (!m) {
int cur = inf, ans = 0;
for (int i = 0; i < n; ++i) {
cur = cur & a[i];
if (cur == m) {
++ans;
cur = inf;
}
}
cout << ans << endl;
}
else {
cout << 1 << endl;
}
}
}
}
ac;
題目5
題目鏈接
題目大意：
給出n個整數數組a，現在可以進行操作：
選擇數組中某個位置k，將a[k]以及之后的數字進行異或操作，將生成的數字放在第k+1位（原來位置k后面的數字被移除）；
現在可以進行任意次上述操作，想知道在這個操作過程中，生成的數字最大為多少。
輸入：
第一行，整數?? 表示t個樣例 ?? (1≤??≤100)
每個樣例兩行
第一行整數?? (1≤??≤1e5).
第二行整數??1,??2,…,????(1≤????≤2^8)
輸出：
每個樣例一行，輸出最大的生成數字。
Examples
input
3
4
0 2 5 1
3
1 2 3
5
8 2 4 12 1
output
7
3
14
題目解析：
n=1時，只有一個值a[1];
n=2時，除了a[1~2]，新增是a[1]&a[2];
n=3時，除了a[1~3]，新增是a[3]&a[2]（選擇2和3合并），a[1]&a[2]（先選擇位置3生成a[4]=a[3]，這樣抵消a[3]，再選擇位置1生成a[1]&a[2]&a[3]&a[4]=a[1]&a[2])，a[1]&a[2]&a[3]（選擇位置1）;
從末尾開始分析可以得知，每個末尾的數字有兩種選擇，要么加入前面的合成，要么復制一次然后被抵消；
題目給出的a[i]的范圍很小，可以由此來降低復雜度，我們用dp[i][j]表示第i個整數往后，拼出結果數字為j的可能性，dp[i][j]=1表示有解，dp[i][j]=0表示無解；
這樣從最后面往前dp就可以得到所有可能出現數字。
class Solution {
static const int N = 202010;
static const int M = 260;
static const int inf = 0x7fffffff;
int a[N];
int dp[N][M];
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n+1; ++i)
for (int j = 0; j < M; ++j) dp[i][j] = 0;
int ans = 0;
for (int i = n - 1; i >= 0; --i) {
dp[i+1][0] = 1;
for (int j = 0; j < M; ++j) {
if (dp[i + 1][j]) {
dp[i][j ^ a[i]] = 1;
ans = max(ans, j ^ a[i]);
}
}
}
cout << ans << endl;
}
}
}
ac;
