前言：处理简单版本的时候，想到了贪心，以及暴力求解顺便剪枝一下，要注意边界问题

haed版本的时候，完全行不通了，m的范围到了200，这是不可以暴力求解的

但是我不知道如何定义状态转移方程，按照我们easy的版本思路，首先我们肯定是要先排序

#include<bits/stdc++.h>
using namespace std;

#define int long long
const int N = (int)205;
const int Mod = (int)998244353;
int n,m;
int ans;
struct node{
	int l,r;
	bool operator<(node b){
		return l < b.l;
	}
}sto[N];

void dfs(int i,int last1,int last2){
	if(i==m+1){
		if(last2>=n){
			ans=(ans+1)%Mod;			
		}
 		return;
	}
	int l = sto[i].l , r = sto[i].r;
	if(l>=last2+2){
		// 不符合条件 
		return; 
	}
	dfs(i+1,max(last1,r),max(last2,min(last1,r)));
	dfs(i+1,last1,last2);
}

signed main(){
	cin >> n >> m;
	for(int i=1;i<=m;i++){
		cin >> sto[i].l >> sto[i].r;
	}	
	sort(sto+1,sto+1+m);
	dfs(1,0,0);
	cout << ans;
	return 0;
}

注意我们离散化的时候左端点减一，这是为了处理我们的衔接边界

#include<bits/stdc++.h>
using namespace std;

#define ll long long
const int N = (int)1e5+10,mod = 998244353;

int dp[401][401][401];
void add(int &ret,int x){
	ret = (ret+x) % mod;
}

void solve(){
	int n,m;
	cin >> n >> m;
	vector<int> v;
	vector<int> s(m+1),t(m+1);
	// 离散化处理
	for(int i=1;i<=m;i++){
		cin >> s[i] >> t[i];
		s[i]--; v.push_back(s[i]);
		v.push_back(t[i]); 
	}  
	// 存储 0 ，n
	v.push_back(0),v.push_back(n);
	sort(v.begin(),v.end());
	v.resize(unique(v.begin(),v.end())-v.begin());
	n = v.size();
	vector<pair<int,int>> a(m+1);
	for(int i=1;i<=m;i++){
		s[i] = lower_bound(v.begin(),v.end(),s[i]) - v.begin();
		t[i] = lower_bound(v.begin(),v.end(),t[i]) - v.begin();
		a[i] = {s[i],t[i]};
	} 
	sort(a.begin()+1,a.end());
	dp[0][0][0] = 1;
	for(int k=1;k<=m;k++){
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				if(dp[k-1][i][j]==0) continue;
				add(dp[k][i][j],dp[k-1][i][j]); // 不取的情况，i和j不改变
				if(a[k].first<=i){
					add(dp[k][max(i,min(a[k].second,j))][max(j,a[k].second)],dp[k-1][i][j]);
				} 
			}
		}
	}
	cout << dp[m][n-1][n-1];
}

int main(){
	solve();
	return 0;
}