Коррекция Многополевое восьмой HDU 1009 (hdu6665) Калабаш и Арендодатель Вычислительная геометрия / ДПП

Значение вопросов:

Указанные два прямоугольника, выходы два прямоугольной плоскости разделен на множество частей.

Решение:

Дорога могла бы быть большими дебаты геометрической вычислительной техникой, и в моей жизни и письменный BFS.

Дискретные краевые ребра не совпадают со средней нотой выплескивать сетки, окруженной кругом и вакантные, то насилие BFS расчета в общей сложности несколько банки.

Метод не так, он не будет никакого насилия, под наблюдением диаграммы, точка и прямоугольника есть 25 видов отношений, а затем две точек определяют прямоугольные, два прямоугольных отношений между общей сложности 625 видов

Что касается таблицы, как играть, как если бы он должен был помочь BFS.

 

#include <iostream> 
#include <очереди> 
#include <алгоритм>  
#include <CString>
 с использованием  пространства имен станд;
Int MAPP [ 11 ] [ 11 ];
INT х [ 5 ], у [ 5 ];
Const  INT changex [ 4 ] = { 0 , 0 , 1 , - 1 };
Const  INT changey [ 4 ] = { 1 , - 1 , 0 , 0 };
недействительный LSH (INT * а) {
     INT б [ 5 ];
    BOOL флаг [ 5 ] = {}; 
    б [ 1 ] = а [ 1 ]; б [ 2 ] = а [ 2 ]; б [ 3 ] = а [ 3 ]; б [ 4 ] = а [ 4 ]; 
    рода (б + 1 , Ь + 5 );
    INT л = уникальный (Ь + 1 , Ь + 5 ) -b- 1 ;
    для ( INT I = 1 ; г <= L; я ++ ) {
         для (INT J = 1 , J <= 4 ; j ++ ) {
             если (а [J] == B [I] && флаг [J] == 0 ) { 
                а [J] = 2 * я; 
                флаг [J] = 1 ; 
            } 
        } 
    } 
    Возврата ; 
} 
Int решения () {
     INT ANS = 0 ; 
    MemSet (MAPP, 0 , SizeOf MAPP);
//     Е ( "а:% d% d% d% d \ п", х [1], у [1], х [2], у [2]);
//     Е ( "б:% d% d% d% d \ п", х [3], у [3], х [4], у [4]);
    для ( INT I = 1 ; г <= 10 ; я ++ ) {
         для ( Int J = 1 , J <= 10 ; j ++ ) {
             если ((я == х [ 1 ] || я == х [ 2 ]) && J> = у [ 1 ] && J <= у [ 2 ]) { 
                MAPP [I] [J] = - 1 ; 
            } 
            Если ((J == у [ 1 ] || J == у [ 2 ]) && я> = х [ 1 ] && г <= х [ 2 ]) { 
                MAPP [I] [J] = - 1 ;
            } 
            Если ((я == х [ 3 ] || я == х [ 4 ]) && J> = у [ 3 ] && J <= у [ 4 ]) { 
                MAPP [I] [J] = - 1 ; 
            } 
            Если ((J == у [ 3 ] || J == у [ 4 ]) && я> = х [ 3 ] && г <= х [ 4 ]) { 
                MAPP [I] [J] = - 1 ; 
            } 
        } 
    } 
    
//     для (INT = 1; г <= 10; я ++) {
 //             для (Int J = 1, J <= 10; j ++) {
 //                 Е ( "% С", МАПП [я] [J] == - 1 '*'?
//             }
 //             Е ( "\ п");
//         } 
 //     
    очереди < INT > QX, QY;
    для ( INT I = 1 ; г <= 10 ; я ++ ) {
         для ( Int J = 1 , J <= 10 ; j ++ ) {
             если (MAPP [I] [J] == 0 ) { 
                ANS ++ ; 
                MAPP [I] [J] = анс; 
                qx.push (я); 
                qy.push (J); 
            }
            в то время как (! {qx.empty ())
                 INT хх = qx.front ();
                INT уу = qy.front (); 
                qx.pop (); qy.pop (); 
//                 Е ( "% d% d:" хх, уу); 
                для ( INT к = 0 ; к < 4 ; K ++ ) {
                     INT ххх = хх + changex [к];
                    INT YYY = уу + changey [к];
//                     Е ( "% d% d", ххх, ууу); 
                    если (ххх> = 1 && ххх <= 10 && YYY> = 1 && YYY <&& MAPP [XXX] [YYY] == 0 ) { 
                        qx.push (ххх); 
                        qy.push (YYY); 
                        MAPP [XXX] [YYY] = анс; 
                    } 
                } 
//                 Е ( "\ п"); 
            }
 //             для (INT I = 1; я <= 10; я ++) {
 //             для (Int J = 1, J = 10 <; j ++) {
 //                 Е ( "% С", MAPP [I] [J ?] == - 1 '*': MAPP [I] [J] + '0');
//             }
 //             Е ( "\ п");
//         } 
        } 
    } 
    возвращение анс;
INT основных () { 
    
    INT т; 
    зсапЕ ( " % d " , & т);
    в то время как (T-- ) { 
        зсапЕ ( " % d% d% d% D " , & х [ 1 ], и у [ 1 ], & х [ 2 ], и у [ 2 ]); 
        Scanf ( " % d% d% d% D " , & х [ 3 ], и у [ 3 ], & х [ 4 ], и у [ 4 ]); 
        LSH (х); LSH (у); 
        Е ( " % d \ п " , решение ());
//        для (INT = 1; я <= 10; я ++) {
 //             для (Int J = 1, J = 10 <; j ++) {
 //                 Е ( "% С", MAPP [I] [J] == ? -1 '*': MAPP [I] [J] + '0');
//             }
 //             Е ( "\ п");
//         } 
    } 
}

 

рекомендация

отwww.cnblogs.com/isakovsky/p/11354391.html