这题看了龙教主的报告才会做 Orz
http://acmicpc.org.cn/wiki/index.php?title=2009_Northwestern_Europe_Mountain_Road_Solution
/*
    题意：一条单向的公路  两端某些时刻有车过来
           给出这些车到达公路端的时间arrive，还有这些车通过这条公路的最短时间run
           要求相继通过某个点的两辆车时间不能少于10，也不能超车，而且不能打乱车来的顺序
           问怎么安排，使得最后通过公路的那辆车的时间最短

    题目给的限制具有顺序性，应想到dp

    dpA[i,j],dpB[i,j]分别表示两边刚好走了i,j辆车的最短时间，A刚走完，B刚走完
    转移的话枚举这某连续走K部车！！

    重要的是要理清车怎么跑：
    起始时间st = max(车到桥的时间T , 上一部车出发后+10)
    到达时间ed = max(车出发后全速前进 , 上一部车到达后+10)
    这样就保证了 “2车通过同一个点的时间间隔要至少是10秒” ！！
    那么此时车行驶时间是ed-st

    启示：这里枚举连续走K部车，跟现实世界一样，放多少部车走    
 */
#include < cstdio >
#include < algorithm >

using   namespace  std;

 const   int  MAXN  =   210 ;
 const   int  INF  =   1000000000 ;

 struct  Car
{
     int  st,run;
};

 int  dpA[MAXN][MAXN],dpB[MAXN][MAXN];

Car carA[MAXN],carB[MAXN];

 int  main()
{
     // freopen("in","r",stdin);
     int  T;
     for (scanf( " %d " , & T);T -- ;)
    {
         int  n,na = 0 ,nb = 0 ;
         char  ch;
        scanf( " %d " , & n);
         for ( int  i = 0 ;i < n;i ++ )
        {
            scanf( "  %c " , & ch);
             if (ch == ' A ' )
            {
                na ++ ;
                scanf( " %d%d " , & carA[na].st, & carA[na].run);
            }
             else
            {
                nb ++ ;
                scanf( " %d%d " , & carB[nb].st, & carB[nb].run);
            }
        }

         // [i,j] -> [k,j]
         // [i,j] -> [i,k]
         for ( int  i = 0 ;i <= na;i ++ )
             for ( int  j = 0 ;j <= nb;j ++ )
                dpA[i][j] = dpB[i][j] = INF;
        dpA[ 0 ][ 0 ] = dpB[ 0 ][ 0 ] = 0 ;
         for ( int  i = 0 ;i <= na;i ++ )
             for ( int  j = 0 ;j <= nb;j ++ )
            {
                 if (dpB[i][j] != INF)
                {
                     int  st  =  max(carA[i + 1 ].st,dpB[i][j]);
                     int  ed  =  st  +  carA[i + 1 ].run;
                    dpA[i + 1 ][j]  =  min(dpA[i + 1 ][j],ed);
                     for ( int  k = i + 2 ;k <= na;k ++ )
                    {
                        st  =  max(st + 10 ,carA[k].st); // must more than st+10
                        ed  =  max(st + carA[k].run,ed + 10 ); // must more than ed+10
                        dpA[k][j]  =  min(dpA[k][j],ed);                        
                    }
                }
                 if (dpA[i][j] != INF)
                {
                     int  st  =  max(carB[j + 1 ].st,dpA[i][j]);
                     int  ed  =  st  +  carB[j + 1 ].run;
                    dpB[i][j + 1 ]  =  min(dpB[i][j + 1 ],ed);
                     for ( int  k = j + 2 ;k <= nb;k ++ )
                    {
                        st  =  max(st + 10 ,carB[k].st); // must more than st+10
                        ed  =  max(st + carB[k].run,ed + 10 ); // must more than ed+10
                        dpB[i][k]  =  min(dpB[i][k],ed);                        
                    }
                }
            }

        printf( " %d\n " ,min(dpA[na][nb],dpB[na][nb]));
    }
     return   0 ;
}