how to be confident while solving math problems?

I feel very unconfident while solving any math problem.

What to do?

# | User | Rating |
---|---|---|

1 | jiangly | 3678 |

2 | Benq | 3602 |

3 | ecnerwala | 3542 |

4 | maroonrk | 3541 |

5 | cnnfls_csy | 3540 |

6 | orzdevinwang | 3493 |

7 | inaFSTream | 3478 |

8 | Um_nik | 3430 |

9 | Geothermal | 3409 |

9 | Rebelz | 3409 |

# | User | Contrib. |
---|---|---|

1 | maomao90 | 174 |

2 | adamant | 164 |

3 | TheScrasse | 161 |

3 | SecondThread | 161 |

3 | awoo | 161 |

6 | nor | 159 |

7 | maroonrk | 158 |

8 | Um_nik | 156 |

9 | BledDest | 145 |

9 | Geothermal | 145 |

how to be confident while solving math problems?

I feel very unconfident while solving any math problem.

What to do?

is Chinese Remainder Theorem necessary to solve the System of linear congruence?

`gcd(a,m) == 1`

then there exists module multiplicative inverse, and also there exists only 1 inverse

suggest me some good problem archive of (CF level >= 1700). Thank you

how to find n such that n % x == 0 and (n + 1) % y == 0 ?

like we do ceil division like this

```
int64_t ceil_div(int64_t a, int64_t b) {
return a / b + ((a ^ b) > 0 && a % b != 0);
}
```

how to do floor division with negative numbers also.

how can i prove my solution both Dp and greedy.

We know that Time Complexity of `std::sort`

is `O(N·log(N))`

. and

Time Complexity of `std::stable_sort`

is `O(N·log^2(N))`

.

The `std::sort`

doesn't preserves the relative order of equal elements while `std::stable_sort`

does. But it is little slower. Can't we just write custom comparator to preserve order like this

```
int N = 1e5;
std::vector<int> A(N, 1);
std::vector<int> order(N);
std::iota(order.begin(), order.end(), 0);
std::sort(order.begin(), order.end(), [&](int i, int j) {
if (A[i] == A[j]) {
return i < j;
}
return A[i] < A[j];
});
```

now the `std::sort`

will also preserve relative order of equal elements than why to use `std::stable_sort`

let array `A = {1,3,1,1,1,4,0,0,2,3,1,}`

We have to do following 2 operations on it

`1.)Decrease all elements from L to R by 1`

`2.)Given i find right most element j such that for each k. i <= k <= j. A[k] > 0`

how can i do this in `log(N)`

?

is there any formula to calculate this in `O(1)`

?

```
int N;
cin >> N;
int answer = 0;
while (N > 1) {
N = sqrt(N);
answer++;
}
cout << answer;
```

what is fractional knapsack. is this a dp problem or greedy ?

Codeforces (c) Copyright 2010-2024 Mike Mirzayanov

The only programming contests Web 2.0 platform

Server time: Feb/21/2024 12:43:18 (j3).

Desktop version, switch to mobile version.

Supported by

User lists

Name |
---|