Динамическое программирование

// LWP_Test.cpp : Defines the entry point for the console application.
//#include <iostream>
#include <fstream>
#include <map>
#include <vector>
#include <iterator>
#include <algorithm>
#include <string>
 
typedef std::map<unsigned int,int> mymap;
typedef std::vector<int> myarr;
 
// Ф-ция считывания исходных данных из файла 
bool readFile(
              const char *str, // Имя файла
              myarr &_arr,     // Массив с кол-вом кирпичей в каждом ряде
              mymap &_map      // Набор блоков
              );
// Ф-ция проверяем может ли быть построена стена из данного набора
// блоков по заданой конструкции
bool verifyWall(
                myarr &_arr, // Массив с кол-вом кирпичей в каждом ряде
                mymap &_map // Набор блоков
                );
// Проверяет и удаляет из набора блоки с нулевым кол-вом
void checkMap(
              mymap &_map // Набор блоков для проверки
              );
 
int main()
{
    mymap _map;
    myarr arr;
    std::string fileName;
 
    std::cout << "Enter file name: ";
    getline( std::cin, fileName );
 
    readFile( fileName.c_str(), arr, _map );
 
    std::cout << ( verifyWall( arr, _map ) ? "Yes" : "No" ) << std::endl;   
 
    system("PAUSE");
    return 0;
}
 
bool readFile( const char *str, myarr &_arr, mymap &_map )
{
    if ( str == NULL )
        return false;
 
    // Отрытие файла
    std::ifstream infile(str);
 
    if ( infile == NULL )
        return false;
 
    // Считывание ширины и высоты стены
    int w, h;
    infile >> w >> h;
    if ( w <= 0 && h <= 0 )
        return false;
 
    // Преобразование схемы стены в количество кирпичей в каждом ряду.
    // При обнаружении дыры в стене,следующая часть ряда считает,
    // как новый ряд для облегчения проверки.
    char tmp;
    int c = 0;
    for (int i = 0; i < h; i++)
    {
        for (int j = 0; j < w; j++)
        {
            infile >> tmp;
            if ( tmp - '0' == 1)
            {
                c++;
            } 
            else if ( c > 0 )
            {
                _arr.push_back( c );
                c = 0;
            }
        }
        if ( c > 0 )
            _arr.push_back( c );
        c = 0;
    }
    // Переворачиваем так, чтобы начинать рассматривать с нижнего ряда стены
    reverse( _arr.begin(), _arr.end() );
 
    // считываем кол-во блоков в наборе
    int s;
    infile >> s;
    if ( s <= 0 )
        return false;
 
    // Заносим инфо о блоков в ассоциативный массив
    // Ключ - вид блока(кол-во кирпичей в блоке)
    // Значение - кол-во блоков.
    int n1, n;
    for (int i = 0; i < s; i++)
    {
        infile >> n1 >> n;
        if ( n1 <= 0 && n <= 0 )
            return false;
 
        _map[n1] = n;
    }
 
    return true;
}
 
bool verifyWall( myarr &_arr, mymap &_map )
{
    // Для хранения значения выражения для данного ряда
    // F(n) = min(F(n - a1), F(n - a2),.., F(n - ak)) + 1. 
    myarr F;
 
    const int INF=1000000000; // условно обозначим бесконечност
    for ( unsigned int i = 0, n = 0; i < _arr.size(); i++ )
    {
        // Времменый контейнер для учета кол-ва блоков в наборе
        mymap snd( _map.begin(), _map.end() );
        // Кол-во кирпичей в данном ряде
        n = _arr[i];
        F.resize( n+1 );
        F[0] = 0; 
 
        for( unsigned int j = 1; j <= n; j++ )
        {                    
            F[j] = INF;
            mymap::iterator it = snd.begin();
            // Перебераем весь набор блоков
            while ( it != snd.end() )
            {
                if( j >= it->first && F[j-it->first]+1 < F[j] ) // Ищем лучший способ заполнить ряд
                {
                    F[j] = F[j-it->first]+1;
                    it->second--; // Уменьшаем кол-во блока
                }
                it++;
                // Проверяем, чтобы в набое не было блоков с нулевым кол-вом.
                checkMap(snd);
            }
        }
    
        // F[n] элемент сожержит кол-во блоков, которыми можно построить данный ряд,
        // если значение равно бесконечности, то данный ряд из данного набора блоков 
        // построить нельзя
        if ( F[n] == INF )
            return false;
        else
            while( n > 0 )
            {
                mymap::iterator it = _map.begin();
                while ( it != _map.end() )
                {
                    if ( F[n-it->first] == F[n]-1 ) // Можем строить данным блоком 
                    {
                        n-=it->first; // умельшаем кол-во кирпичей в ряде
                        it->second--; // уменьшаем кол-во используемого блока
                        checkMap( _map );
                        break;
                    }
                    it++;
                }
            }
 
        F.clear();
    }
 
    return true;
}
 
void checkMap( mymap &_map )
{
    mymap::iterator it = _map.begin(), itcur;
    while ( it != _map.end() )
    {
        if ( it->second == 0 )
            _map.erase( it++ );
        else
            it++;
    }
}

void func1(int len, int x, int t)
{
    if(len==0)
        func(t+1);
    for(i=x; i<X; i++)//перебираем имеющиеся кирипичи
    {
        if()//если размер очередного кирпича (y) меньше или равен оставшеся len
        {
            //убираем этот кирпич из b[]
            func1(len-y,i,t);
            //восстанавливаем этот кирпич обратно в b[]
        }
    }
}
 
 
void func(int t)// где t номер ряда единичных кирпичей, а сама функция перебирает все существующие ряды и вызывает другую функцию func1(), которая будет из пытаться заполнить с помощью существующего набора кирпичей 
{
    if(t==N)//если t равно количеству рядов
    {
        // выводим на экран "Yes" и заканчиваем программу
    }
    func1(b[t],0, t);// вызываем функцию, которая будет из пытаться заполнить с помощью существующего набора кирпичей t-ый ряд (в параметрах передаем размер ряда под номером t, номер кирпича с которого начинаем заполнять ряд, и номер ряда)
 
}
 
 
int main(){
    func(0);
    cout<<"No"<<endl;
 
    return 0;
}