# 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 == homePos && startPos == homePos) {
return 0;
}

int sx = startPos, sy = startPos;//Start row
int hx = homePos, hy = homePos;//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   ## 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  ## 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): Posted on Mon, 29 Nov 2021 04:59:14 -0500 by netrepsa