#include <bits/stdc++.h>
using namespace std;

int m, n;
string a[1005];

bool check(int rows_to_delete) {
    int start_row = rows_to_delete; // Dòng bắt đầu (0-indexed)
    if (start_row >= m) return true; // Xóa hết hoặc chỉ còn 1 dòng

    set<string> col_signatures;
    for (int j = 0; j < n; ++j) {
        string col_str = "";
        for (int i = start_row; i < m; ++i) {
            col_str += a[i][j];
        }
        if (col_signatures.count(col_str)) return false;
        col_signatures.insert(col_str);
    }
    return true;
}

int main() {
    if (!(cin >> m >> n)) return 0;
    for (int i = 0; i < m; ++i) cin >> a[i];

    // Tìm số dòng xóa lớn nhất
    // Thử xóa từ 0 dòng đến m-1 dòng
    int ans = 0;
    for (int k = 0; k < m; ++k) {
        if (check(k)) {
            ans = k;
        } else {
            break; // Nếu k dòng không được thì k+1 cũng không được
        }
    }
    cout << ans << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <set>
#include <string>
using namespace std;

bool check_columns(const vector<string>& matrix, int rowsToDelete) {
    int M = matrix.size();
    int N = matrix[0].size(); 
    set<vector<char>> seen_columns; 
    for (int col = 0; col < N; col++) {
        vector<char> current_column;
        for (int row = rowsToDelete; row < M; row++) {
            current_column.push_back(matrix[row][col]);
        }
        if (seen_columns.count(current_column)) {
            return false;
        }
        seen_columns.insert(current_column);
    }
    return true; 
}

int main() {
    int M, N;
    cin >> M >> N;
    vector<string> matrix(M);
    for (int i = 0; i < M; i++) {
        cin >> matrix[i];
    }
    int left = 0, right = M - 1;
    int maxDelete = 0;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (check_columns(matrix, mid)) {
            maxDelete = mid; 
            left = mid + 1; // Thử xóa nhiều hơn
        } else {
            right = mid - 1; // Phải xóa ít hơn
        }
    }
    cout << maxDelete << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int m, n, t, ok;
long long f[1001][1001], mod = 1e9 + 7;
char a[1001][1001];

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> m >> n;
    // Đọc dữ liệu, lưu theo cột hoặc hàng đều được, code gốc đọc ngược để tính hash từ dưới lên
    // Ở đây f[i][j] là hash của cột j考虑 các dòng từ 1 đến i (theo input reversed)
    // Thực tế input là m dòng, code đọc từ m về 1.
    for (int i = m; i >= 1; i--) {
        for (int j = 1; j <= n; j++) {
            cin >> a[i][j];
        }
    }

    // Tính hash prefix cho các cột
    // f[i][j] = hash của cột j từ dòng 1 đến i (dòng 1 là dòng cuối cùng của input)
    // Công thức: hash = (hash_truoc * 26 + val) % mod
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            f[i][j] = (f[i - 1][j] * 26 + a[i][j] - 'a' + 1) % mod;
        }
    }

    // Tìm dòng bắt đầu (từ dưới lên)
    // t là dòng bắt đầu (1-indexed)
    t = 1;
    while (t <= m) {
        ok = 1;
        // Kiểm tra tất cả các cột có hash bằng nhau tại dòng t hay không
        // Nếu có, nghĩa là các cột từ dòng t trở lên (tới m) bị trùng?
        // Không, logic code này đang kiểm tra các cột tại "điểm cắt".
        // Thực ra code này đang tìm dòng bắt đầu sao cho các cột phân biệt.
        // Nếu f[t][j] == f[t][i] thì cột i và j từ dòng t đến m là giống nhau.
        for (int i = 1; (i <= n) && (ok); i++)
            for (int j = i + 1; (j <= n) && (ok); j++)
                if (f[t][j] == f[t][i]) {
                    t++; // Nếu trùng, thử bắt đầu từ dòng tiếp theo
                    ok = 0;
                }
        if (ok) break; // Không còn trùng lặp, tìm được t
    }
    // t là số dòng được giữ lại từ dưới lên (tức là dòng t, t+1, ..., m)
    // Nếu input đọc ngược, t là chỉ số dòng thực tế.
    // Số dòng xóa được là m - t.
    cout << (m - t);
}