Very nice problem. I'll explain my solution.

• First part: When we swap adjacent elements, we are either creating a new inversion or removing one. If we make K adjacent swaps, we'll end up with at most K inversions and the total number of inversions will have the same parity as K. To calculate this, we can use bottom-up DP. Let A_i, j be the amount of arrays of length i with j inversions. Suppose we are at state i, j and we want to add element i + 1 to the current array. We have i + 1 positions to choose from, and each position will create one inversion more than the position to its right. If we push it to the back of the array, we won't create any new inversion, and if we push it to the front of the array, we'll be creating i new inversions. So we will need to add A_i, j to all elements A_i, k with k in the range [j, j + i]. This process is O(n³) if done naively, so if we want it to run in time, we will need to use a BIT to do range additions.
• Second part: A permutation can be seen as a collection of cycles. The identity permutation (1,2,3,4,...,N) has N cycles. When we swap two elements, if they belong to the same cycle, we'll be dividing this cycle into two cycles, and if they belong to different cycles, we'll be merging them. So, we are either creating a new cycle or removing one cycle by merging two different cycles. If we make at most K swaps in total, we will have at least N - K cycles in the end. To calculate this, we can use bottom-up DP too. Let B_i, j be the amount of permutations of length i with j cycles. Suppose we are at state i, j and we want to add element i + 1. We have two choices here, the first one being to point it to itself, creating a new cycle, and the second choice to point it to some previous element (making that previous element point to the new one in the process), effectively extending one existing cycle's length by 1. We have i positions for the second choice, so we have to add B_i, j to B_{i + 1, j + 1} and B_i, j * i to B_{i + 1, j}. This process is O(N²), so we don't need any special data structure.

#include <bits/stdc++.h>
#define f(i,a,b) for(int i = (a); i <= (b); i++)

typedef long long ll;
using namespace std;

const ll MOD = 1000000007;
int N, K;
ll A[2505][2505], T[2505], B[2505][2505];

void update(int x, ll v)
{
    while(x <= 2501)
    {
        T[x] = (T[x]+v) % MOD;
        x += x&-x;
    }
}

void update(int l, int r, ll v)
{
    l++, r++;
    update(l,v), update(r+1,-v);
}

ll query(int x)
{
    x++;
    ll ret = 0;
    while(x>0)
    {
        ret = (ret+T[x]) % MOD;
        x -= x&-x;
    }
    return ret;
}

int main()
{
    // A[i][j] = Amount of permutations of length i with j inversions

    A[1][0] = 1;
    f(i,1,2499)
    {
        f(j,0,2500) update(j,min(j+i,2500),A[i][j]);
        f(j,0,2500) A[i+1][j] = query(j);
        f(j,0,2501) T[j] = 0;
    }

    // B[i][j] = Amount of identity graphs with j cycles

    B[1][1] = 1;
    f(i,1,2499) f(j,1,i)
    {
        B[i+1][j+1] = (B[i+1][j+1] + B[i][j]) % MOD;
        B[i+1][j] = (B[i+1][j] + B[i][j]*i) % MOD;
    }

    // Test Case

    cin >> N >> K;
    ll ans = 0, ans2 = 0;
    for(int j = K; j >= 0; j -= 2) ans += A[N][j];
    f(i,0,min(K,N-1)) ans2 += B[N][N-i];
    cout << ans%MOD << " " << ans2%MOD << "\n";
}