# Topic 1

Force buckle: 2087. Minimum cost of robot home in grid graph

## thinking

When you get the title, you must read it first!!!!! To sum up: This is the brain turn to TM....

1. At first glance, it is very similar to our usual robot walking problem. We must read the question carefully!

2. His cost calculation rule is to go to line I and spend rowCosts[i], only one step at a time. Then I go directly from the current line to the destination without detour, and the line I pass is fixed

3. If we don't go there directly, instead of going there directly, the above expenses will be inevitable, and there will be more expenses than useless

4. In conclusion, the direct cost is the smallest.

## code

class Solution { public: int minCost(vector<int>& startPos, vector<int>& homePos, vector<int>& rowCosts, vector<int>& colCosts) { if (startPos[0] == homePos[0] && startPos[1] == homePos[1]) { return 0; } int sx = startPos[0], sy = startPos[1];//Start row int hx = homePos[0], hy = homePos[1];//Terminate row and column int ans = 0; //that 's ok if (sx <= hx) {//Judge whether it is small to large or large to small for (int i = sx + 1; i <= hx; i++) { ans += rowCosts[i]; } } else { for (int i = sx - 1; i >= hx; i--) { ans += rowCosts[i]; } } //column if (sy <= hy) {//Judge whether it is small to large or large to small for (int i = sy + 1; i <= hy; i++) { ans += colCosts[i]; } } else { for (int i = sy - 1; i >= hy; i--) { ans += colCosts[i]; } } return ans; } };

All codes pass the buckle test

(after multiple tests, the shortest time is):

# Topic 2

Force buckle: 2086. Minimum number of buckets required to collect rainwater from the house

## Idea: greedy method

1. We should put the bucket on the open space to receive the water from the eaves, and the bucket should be at least, so only the open space beside the house is meaningful. If there is no open space on both sides of a house, there is no solution

2. At the same time, not all the open spaces beside the house should remember our purpose to minimize the barrels, so a barrel should be used as much as possible

3. Therefore, when examining the value of an open space, if there are houses on both sides and there is no bucket next to the two houses, it is 2, otherwise it is 1, and 0 means it can't be put.

4. Finally, each time the bucket is put on the side with high value.

5. At this point, the analysis is completed.

## code

class Solution { public: int minimumBuckets(string street) { unordered_set<int> item;//All open space locations, disappear after draining the bucket unordered_set<int> item_H;//It is also the location of all houses for fast matching unordered_set<int> right;//A house with a bucket vector<int> H;//Save all house locations int ans = 0; for (int i = 0; i < street.size(); i++) {//initialization if (street[i] == 'H') { H.push_back(i); item_H.insert(i); } else { item.insert(i); } } for (int i = 0; i < H.size(); i++) { if (right.count(H[i]) == 0) {//A house with a bucket ans++; int pos_l = H[i] - 1;//Left and right bucket positions int pos_r = H[i] + 1; int cnt_l = 0;//value int cnt_r = 0; if (item.count(pos_l) > 0) {//Can hold a bucket if (item_H.count(pos_l - 1) > 0 && right.count(pos_l - 1) == 0) {//There are rooms without buckets on the left and right sides of the bucket cnt_l = 2; } else { cnt_l = 1; } } if (item.count(pos_r) > 0) {//The same is true for the right side if (item_H.count(pos_r + 1) > 0 && right.count(pos_l + 1) == 0) { cnt_r = 2; } else { cnt_r = 1; } } if (cnt_l == 0 && cnt_r == 0) {//Not on either side. unsolvable return -1; } else if (cnt_l > cnt_r) {//Pick the side with the greatest value item.erase(pos_l);//Erase position if (cnt_l == 2) { right.insert(H[i]); right.insert(H[i] - 2); } else { right.insert(H[i]); } } else { item.erase(pos_r); if (cnt_r == 2) { right.insert(H[i]); right.insert(H[i] + 2); } else { right.insert(H[i]); } } } } return ans; } };

All codes pass the buckle test

(after multiple tests, the shortest time is):

# Topic 3

Force buckle: 2085. Count the public strings that have appeared once

## thinking

Violence simulation

## code

class Solution { public: int countWords(vector<string>& words1, vector<string>& words2) { unordered_map<string, int> item1; unordered_map<string, int> item2; int ans = 0; for (string tmp : words1) { item1[tmp]++; } for (string tmp : words2) { item2[tmp]++; } for (int i = 0; i < words1.size(); i++) { if (item1[words1[i]] == 1) { if (item2[words1[i]] == 1) { ans++; } } } return ans; } };

All codes pass the buckle test

(after multiple tests, the shortest time is):