import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.StringTokenizer;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    static char[][] arrs;//存矩阵

    public static void main (String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(System.out);
        StringTokenizer tokenizer = new StringTokenizer(reader.readLine());
        int n = Integer.parseInt(tokenizer.nextToken()); //行数
        int m = Integer.parseInt(tokenizer.nextToken()); //列数
        arrs = new char[n][m];
        int k = Integer.parseInt(tokenizer.nextToken()); //最多可以染色的数量
        for (int i = 0; i < n; i++) {
            String s = reader.readLine();
            for (int j = 0; j < m; j++) {
                arrs[i][j] = s.charAt(j);
            }
        }
        PriorityQueue<Integer> queue = numberOfArrs(n,m); //大根堆,排序是O(n*logn)
        if (queue.isEmpty()) {
            writer.println(0);
        } else {
            int result = 0;
            while (!queue.isEmpty() && k > 0) {
                int num = queue.poll();
                if (k >= num) {
                    k -= num;
                    result += num - 1;
                } else {
                    result += k - 1;
                    k=0;
                }
            }
            writer.println(result);
        }
        reader.close();
        writer.flush();
        writer.close();
    }

    public static PriorityQueue<Integer> numberOfArrs(int n, int m) {
        PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2)->o2 - o1);
        for (int p = 0; p < m; p++) {
            int len=0;
            for (int up = Integer.MIN_VALUE,down=0; down < n;down++ ) {//滑动窗口
                if(arrs[down][p]=='o'){
                    up=down;
                    down++;
                    while(down!=n && arrs[down][p]=='o'){
                        down++;
                    }
                    len=down-up;
                    queue.add(len);
                } 
            }
        }
        return queue;
    }




}

滑动窗口+优先级队列（堆）：

滑动窗口用来确定每段连续的长度，时间复杂度总体是O(n^m)；这个没治，必须都要遍历一遍。

优先级队列（堆）用来排序，这里是大根堆，用的话时间复杂度O(n*logn)；

总体时间复杂度：O(n^2);