Important information: Google announced that, from September 2026, Android devices will require ALL apps to be signed by Google, effectively leading to an iOS situation. Value your right to a computer that does what you want; do not tolerate this monopolistic practice! Contact me if you don't understand why it is bad. Click to learn more.

codul

by roundabout, Friday, 16 October 2026, 13:47:43 (1792158463), pushed by roundabout, Friday, 16 October 2026, 13:48:01 (1792158481)

Author identity: Vlad <vlad.muntoiu@gmail.com>

94bfb56196857fcd122faf8a9f84922b8ef35eb4

matrice-sp-patrat.cc

@@ -0,0 +1,73 @@

                                
                                
                                
                            
                                
                                    
                                        
                                        #include <iostream>
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        #include <vector>
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        using std::vector;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        template <typename T>
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        inline T safe_get(vector<vector<T>> const &a, int const i, int const j) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            if (i < 0 || a.size() <= i || j < 0 || a[0].size() <= j) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                return 0;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            return a[i][j];
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        inline long long int get_ps(vector<vector<long long int>> const &ps,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                                    int const i0, int const j0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                                    int const i1, int const j1) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            return safe_get(ps, i1, j1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                   - safe_get(ps, i0-1, j1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                   - safe_get(ps, i1, j0-1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                   + safe_get(ps, i0-1, j0-1);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        int main() {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            using std::cin, std::cout;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            int N, M;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            long long int K;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            cin >> N >> M >> K;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            vector<vector<int>> mat(N, vector<int>(M));
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            for (int i=0; i<N; i++) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                for (int j=0; j<M; j++) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    cin >> mat[i][j];
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                } 
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            vector<vector<long long int>> ps(N, vector<long long int>(M));
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            for(int i=0;i<N;i++){
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                for(int j=0;j<M;j++){
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    ps[i][j] = safe_get(ps, i-1, j) + safe_get(ps, i, j-1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                               - safe_get(ps, i-1, j-1) + mat[i][j];
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            vector<vector<int>> min_size(N, vector<int>(M));
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            for (int i = 0; i < N; ++i) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                for (int j = 0; j < M; ++j) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    int const prev_size = std::max(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                        std::max(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                            safe_get(min_size, i-1, j),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                            safe_get(min_size, i, j-1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                        ),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                        3
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    );
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    int size = (prev_size-1) / 2 - 1;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    long long int sum = get_ps(ps, i-size, j-size, i+size, j+size);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    while (sum < K && i - (size+1) >= 0 && j - (size+1) >= 0 && i + (size+1) < N && i + (size+1) < M) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                        ++size;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                        sum = get_ps(ps, i-size, j-size, i+size, j+size);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    if (sum < K) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                        min_size[i][j] = -1;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    } else {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                        min_size[i][j] = 2*size+1;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            for (int i = 0; i < N; ++i) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                for (int j = 0; j < M; ++j) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                    cout << min_size[i][j] << ' ';
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                                cout << '\n';
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            return 0;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        }