Go: package main

import (
        "fmt"
)

var paper [10][10]int

func main() {
        var x, y, s int
        for {
                _, err := fmt.Scanf("%d,%d,%d", &x, &y, &s)
                if err != nil {
                        break
                }

                fill(x, y, s)
        }
        var d, z int
        for i := 0; i < 10; i++ {
                for j := 0; j < 10; j++ {
                        if paper[i][j] == 0 {
                                z += 1
                        }
                        if paper[i][j] > d {
                                d += 1
                        }
                }
        }
        fmt.Printf("%d\n%d\n", z, d)
}

func fill(x int, y int, s int) {
        paper[x][y] += 1
        if x > 0 {
                paper[x-1][y] += 1
        }
        if x < 9 {
                paper[x+1][y] += 1
        }
        if y > 0 {
                paper[x][y-1] += 1
        }
        if y < 9 {
                paper[x][y+1] += 1
        }

        if s >= 2 {
                if x > 0 && y > 0 {
                        paper[x-1][y-1] += 1
                }
                if x > 0 && y < 9 {
                        paper[x-1][y+1] += 1
                }
                if x < 9 && y > 0 {
                        paper[x+1][y-1] += 1
                }
                if x < 9 && y < 9 {
                        paper[x+1][y+1] += 1
                }
        }

        if s > 2 {
                if x > 1 {
                        paper[x-2][y] += 1
                }
                if x < 8 {
                        paper[x+2][y] += 1
                }
                if y > 1 {
                        paper[x][y-2] += 1
                }
                if y < 8 {
                        paper[x][y+2] += 1
                }
        }
}

C++: #include <iostream>
using namespace std;

#define SAFE_DELETE( x ) { if ( x ){ delete x; x = NULL; } }

struct tCell{
	tCell(){
		x = y = size = 0;
		prev = next = NULL;
	}
	int x, y, size;
	tCell *prev, *next;
};

class MyArray{
public:
	MyArray() : size( 0 ), head( NULL ), tail( NULL ){
		head = new tCell;
		tail = new tCell;
		head->next = tail;
		tail->prev = head;
	}
	~MyArray(){
		for( int i = size; i > 0; --i ){
			tCell* cell = tail->prev;
			cell->prev->next = cell->next;
			cell->next->prev = cell->prev;
			SAFE_DELETE( cell );
		}
		SAFE_DELETE( tail );
		SAFE_DELETE( head );
	}

	void pushBack( int x, int y, int size ){
		++this->size;
		tCell* cell = new tCell;
		cell->x = x;
		cell->y = y;
		cell->size = size;
		cell->prev = tail->prev;
		cell->next = tail;
		cell->prev->next = cell;
		cell->next->prev = cell;
	}
	int getSize(){ return size; }

	tCell operator[]( int d ){
		tCell* cell = head->next;
		if ( d >= size ){ cell = NULL; return *cell; }
		for ( int i = 0; i < d; ++i ){
			cell = cell->next;
		}
		return *cell;
	}

private:
	int size;
	tCell *head, *tail;
};

const unsigned SX = 14;
const unsigned SY = 14;

void putInk( int x, int y, int* board, int* sample ){
	for ( int j = -2; j < 3; ++j ){
		for ( int i = -2; i < 3; ++i ){
			board[ ( y+j ) * SY + ( x+i ) ] += sample[ ( j+2 ) * 5 + ( i+2 ) ];
		}
	}
}

int main(){
	int x, y, size;
	char c;
	MyArray ma;
	int board[ SY * SX ];
	for ( int j = 0; j < SY; ++j ){
		for ( int i = 0; i < SX; ++i ){
			board[ j*SX + i ] = 0;
		}
	}

	int small[ 5 * 5 ];
	int medium[ 5 * 5 ];
	int large[ 5 * 5 ];
	for ( int j = 0; j < 5; ++j ){
		for ( int i = 0; i < 5; ++i ){
			small[ j*5 + i ] = medium[ j*5 + i ] = large[ j*5 + i ] = 0;
			if ( ( i >= 1 && i <=3 ) && ( j >= 1 && j <= 3 ) ) {
				small[ j*5 + i ] = medium[ j*5 + i ] = large[ j*5 + i ] = 1;
			}
			if ( ( i == 1 || i == 3 ) && ( j == 1 || j == 3 ) ) {
				small[ j*5 + i ] = 0;
			}
			if ( i == 2 || j == 2 ) {
				large[ j*5 + i ] = 1;
			}
		}
	}

	while ( cin >> x >> c >> y >> c >> size ){
		ma.pushBack( x+2, y+2, size );
	}

	for ( int i = 0; i < ma.getSize(); ++i ){
		x = ma[ i ].x;
		y = ma[ i ].y;
		size = ma[ i ].size;
		int* sample;
		switch ( size ){
			case 1 : sample = small; break;
			case 2 : sample = medium; break;
			case 3 : sample = large; break;
		}
		putInk( x, y, board, sample );
	}

	int blank = 0, depth = 0;
	for ( int j = 2; j < SY-2; ++j ){
		for ( int i = 2; i < SX-2; ++i ){
			if ( !board[ j * SY + i ] ) ++blank;
			else if ( depth < board[ j * SY + i ] ) depth = board[ j * SY + i ];
		}
	}

	cout << blank << endl << depth << endl;

	return 0;
}

C++: #include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
// Dropping Ink (0026)
int main()
{
    vector<vector<int> > paper(10, vector<int>(10));
    int ret1 = 100;
    int ret2 = 0;
 
    int dx[] = {0, 0, 0, 1, -1, 1, 1, -1, -1, 0, 0, 2, -2}; 
    int dy[] = {0, 1, -1, 0, 0, 1, -1, 1, -1, 2, -2, 0, 0};

    for(;;){
       int x0, y0, size;
       char c;
       if(!(cin >> x0 >> c >> y0 >> c >> size))
            break;
        for(int i=0; i<4*size+1; ++i){
            int y = y0 + dy[i];
            int x = x0 + dx[i];
            if(y < 0 || y > 9 || x < 0 || x > 9)
                continue;
            if(paper[y][x] == 0)
                -- ret1;
            ++ paper[y][x];
            ret2 = max(ret2, paper[y][x]);
        }
    }
 
    cout << ret1 << endl << ret2 << endl;
}

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

int field[10][10];

int main() {
  int x,y,size; 
  char ch;
  while ( cin >> x >> ch >> y >> ch >> size ) {
    for ( int i = 0; i < 10; i++ ) {
      for ( int j = 0; j < 10; j++ ) {
	field[i][j] = 0;
      }
    }

    if ( size == 1 ) {
      field[y][x]++;
      if ( x-1 >= 0 ) field[y][x-1]++;
      if ( x+1 < 10 ) field[y][x+1]++;
      if ( y-1 >= 0 ) field[y-1][x]++;
      if ( y+1 < 10 ) field[y+1][x]++;

    } else if ( size == 2 ) {
      field[y][x]++;
      if ( x-1 >= 0 ) field[y][x-1]++;
      if ( x+1 < 10 ) field[y][x+1]++;
      if ( y-1 >= 0 ) field[y-1][x]++;
      if ( y+1 < 10 ) field[y+1][x]++;
      if ( x+1 < 10 && y+1 < 10 ) field[y+1][x+1]++;
      if ( x-1 >= 0 && y+1 < 10 ) field[y-1][x+1]++;
      if ( x+1 < 10 && y-1 >= 0 ) field[y+1][x-1]++;
      if ( x-1 >= 0 && y-1 >= 0 ) field[y-1][x-1]++;
    } 

    if ( size == 3 ) {
      field[y][x]++;
      if ( x-1 >= 0 ) field[y][x-1]++;
      if ( x+1 < 10 ) field[y][x+1]++;
      if ( y-1 >= 0 ) field[y-1][x]++;
      if ( y+1 < 10 ) field[y+1][x]++;
      if ( x+1 < 10 && y+1 < 10 ) field[y+1][x+1]++;
      if ( x-1 >= 0 && y+1 < 10 ) field[y-1][x+1]++;
      if ( x+1 < 10 && y-1 >= 0 ) field[y+1][x-1]++;
      if ( x-1 >= 0 && y-1 >= 0 ) field[y-1][x-1]++;
      if ( x+2 < 10 ) field[y][x+2]++;
      if ( x-2 >= 0 ) field[y][x-2]++;
      if ( y+2 < 10 ) field[y+2][x]++;
      if ( y-2 >= 0 ) field[y-2][x]++;
    }

  }
 
  int cnt = 0,maxv = 0;

  for ( int i = 0; i < 10; i++ ) {
    for ( int j = 0; j < 10; j++ ) {
      if ( field[i][j] == 0 ) cnt++;
      maxv = max(maxv,field[i][j]);
    }
  }

  cout << cnt << endl;
  cout << maxv << endl;
  
  return 0;
}