DouKaku?

#include<iostream>
#include<vector>

using namespace std; 

#define DEBUG(c) cerr<<"> "<<#c<<" = "<<c<<endl; 

#define R 150
#define S 10

vector<vector<pair<int,int> > > st;

int w(int r,int s,int rr,int i)
{
    return (st[r][s].second+st[rr][i].second)*(abs(st[r][s].first-st[rr][i].first));
}

int min(int a,int b)
{
    if(std::min(a,b)==-1)
        return std::max(a,b);
    
    return std::min(a,b);
}

int main()
{
    
    int n,m; cin>>n>>m;
    
    st.resize(n);
    for(int i=0;i<n;i++)
    {
        int k; cin>>k;
        for(int j=0;j<k;j++)
        {
            int x,d; cin>>x>>d;
            st[i].push_back(make_pair(x,d));
        }
    }
    
    int dp[R][S],dp2[R][S];
    memset(dp,-1,sizeof(int)*R*S);
    
    for(int step=0;step<=m;step++)
    {
        memcpy(dp2,dp,sizeof(int)*R*S);
        for(int r=0;r<n;r++)
        {
            for(int s=0;s<st[r].size();s++)
            {
                if(r==0)
                    dp[r][s]=0;
                else
                {
                    for(int i=0;i<st[r-1].size();i++)
                        if(dp[r-1][i]!=-1)
                            dp[r][s]=min(dp[r][s],dp[r-1][i]+w(r,s,r-1,i));
                }
                
                if(step==0 || r==0)
                    continue;
                
                if(r==1)
                    dp[r][s]=0;
                else
                {
                    for(int i=0;i<st[r-2].size();i++)
                        if(dp2[r-2][i]!=-1)
                            dp[r][s]=min(dp[r][s],dp2[r-2][i]+w(r,s,r-2,i));
                }
            }
        }
    }
    
    //もうゴール、してもいいよね…
    int res=-1;
    for(int i=0;i<S;i++)
        res=min(res,min(dp[n-1][i],dp2[n-2][i]));
    
    cout<<res<<endl;
    
    return 0;
}

#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <limits>
#include <cassert>

#define REP(i, b, e) for (size_t i = b; i < e; ++i)
#define REPE(i, b, e) for (size_t i = b; i <= e; ++i)

void fill(std::vector<long>& v, long value)
{
    std::fill(v.begin(), v.end(), value);
}

int main()
{
    const size_t max_x = 1000;

    std::string s;

    std::getline(std::cin, s);

    size_t n, m;

    std::istringstream(s) >> n >> m;

    assert(2 <= n && n <= 150);

    assert(m <= (n + 1) / 2);

    std::vector<std::vector<long> > slip(n + 3, std::vector<long>(max_x, -1)); // -1 means there is no stone

    fill(slip[0], 0); // start shore (0 is dummy value)

    fill(slip[n + 1], 0); // goal shore (0 is dummy value)

    fill(slip[n + 2], 0); // goal shore (0 is dummy value)

    REPE(y, 1, n)
    {
        std::getline(std::cin, s);

        std::istringstream sin(s);

        size_t k;

        sin >> k;

        assert(k <= 10);

        for (; k; --k)
        {
            size_t x;

            long d;

            sin >> x >> d;

            assert(1 <= x && x <= max_x);

            assert(1 <= d && d <= 1000);

            --x; // now starts with 0 not 1

            slip[y][x] = d;
        }
    }

    std::vector<std::vector<std::vector<long> > > dp(n + 3,
        std::vector<std::vector<long> >(max_x,
            std::vector<long>(m + 1, std::numeric_limits<long>::max())));

    dp.front().swap(
        std::vector<std::vector<long> >(max_x,
            std::vector<long>(m + 1, 0)));

    REPE(y1, 0, n) REP(x1, 0, max_x) if (slip[y1][x1] >= 0) // source
    {
        REPE(y2, y1 + 1, y1 + 2) REP(x2, 0, max_x) if (slip[y2][x2] >= 0) // destinition
        {
            const size_t now_jumped = y2 - y1 - 1;

            assert(now_jumped == 0 || now_jumped == 1);

            for (size_t old_jumped = 0; old_jumped + now_jumped <= m; ++old_jumped)
            {
                if (dp[y1][x1][old_jumped] != std::numeric_limits<long>::max())
                {
                    long& src = dp[y1][x1][old_jumped];

                    long& dst = dp[y2][x2][old_jumped + now_jumped];

                    dst = std::min(dst, src + (slip[y1][x1] + slip[y2][x2]) * long(x2 > x1 ? x2 - x1 : x1 - x2));
                }
            }
        }
    }

    long result = std::numeric_limits<long>::max();

    REPE(y, n + 1, n + 2) REP(x, 0, max_x) REPE(jumped, 0, m) // goal shore
    {
        result = std::min(result, dp[y][x][jumped]);
    }

    std::cout << result << std::endl;
}