The following is my simple lookup-table based solution of the problem.

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

int main() {
    const int N = 26;
    string cowphabet, heard;
    cin >> cowphabet >> heard;
    int pos[N];
    for (int i = 0; i < N; ++i)
        pos[cowphabet[i]-'a'] = i;
    int prev = N, ans = 0;
    for (auto c: heard) {
        const int p = pos[c-'a'];
        if (p <= prev)
            ++ans;
        prev = p; }
    cout << ans;
    return 0; }

My solution in python.

# Uddered but not Herd

cowphabet = input()
cowphabet = list(cowphabet)
string = input()

times = 1

for i in range(1, len(string)):
    if cowphabet.index(string[i-1]) >= cowphabet.index(string[i]):
        times+=1
        
print(times)

This is a USACO Bronze problem, which means it is solvable without the use of any advanced algorithms or challenging mathematics; just basic implementation and some logical thinking. If you are thinking about LISs and Dilworth's Theorem, this is a clear indicator that you have seriously overcomplicated the problem. (General lesson: always keep in mind the difficulty level of a problem when thinking about how to solve it.)

There is a very simple $$$O(n)$$$ solution described at the bottom of the official editorial. The basic idea is to just try to hum each character in the input one by one, and, whenever we have to "go backwards" in the cowphabet, we have to increase the answer by 1.

Hope that helps.