diff --git a/maximum-subarray-sum/maximum-subarray-sum-tutorial.pdf b/maximum-subarray-sum/maximum-subarray-sum-tutorial.pdf
new file mode 100644
index 0000000..74c8748
Binary files /dev/null and b/maximum-subarray-sum/maximum-subarray-sum-tutorial.pdf differ
diff --git a/maximum-subarray-sum/maximum-subarray-sum-tutorial.tex b/maximum-subarray-sum/maximum-subarray-sum-tutorial.tex
new file mode 100644
index 0000000..f4c5394
--- /dev/null
+++ b/maximum-subarray-sum/maximum-subarray-sum-tutorial.tex
@@ -0,0 +1,60 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+
+\title{ Tutorial: Maximum Subarray Sum}
+\author{}
+\date{}
+\begin{document}
+\maketitle
+O problema pode ser resolvido eficientemente utilizando uma abordagem de \textbf{programação dinâmica}, comumente conhecida como \textbf{Algoritmo de Kadane}. A ideia central é calcular, para cada posição $i$ da sequência, a maior soma de uma subsequência contínua que termina exatamente naquela posição.
+
+\subsection*{Modelagem}
+
+Dada uma sequência de entrada $A$ de tamanho $n$ (com índices de $0$ a $n-1$), queremos encontrar a maior soma possível $\sum_{k=i}^{j} A[k]$ para quaisquer índices $0 \leq i \leq j < n$.
+
+O algoritmo de Kadane resolve isso de forma linear, mantendo o controle da melhor subsequência encontrada até o momento.
+
+\subsection*{Definição da DP}
+
+Definimos $dp[i]$ como o valor da \textbf{maior soma de uma subsequência contínua que termina no índice $i$}.
+
+\subsection*{Função de Transição}
+
+Para calcular o valor de $dp[i]$, temos duas escolhas:
+
+A subsequência máxima que termina em $i$ é formada \textbf{apenas pelo elemento $A[i]$}. Isso ocorre se a soma da subsequência anterior ($dp[i-1]$) for negativa, pois estendê-la apenas diminuiria o valor.
+
+A subsequência máxima que termina em $i$ é uma \textbf{extensão da subsequência máxima que terminava em $i-1$}, adicionando $A[i]$. A soma seria $dp[i-1] + A[i]$.
+
+Selecionamos a maior dessas duas opções. Portanto, a função de transição é:
+
+$$dp[i] = \max(A[i], \quad dp[i-1] + A[i])$$
+
+\subsection*{Casos Base}
+
+A primeira subsequência possível (que termina no índice $0$) deve obrigatoriamente conter $A[0]$.
+O caso base é:
+
+$$dp[0] = A[0]$$
+
+\subsection*{Resposta Final}
+
+É importante notar que $dp[n-1]$ é apenas a maior soma terminando na última posição, o que não é necessariamente a resposta final do problema.
+
+A subsequência de soma máxima pode terminar em qualquer índice $i$. Portanto, a resposta final é o \textbf{valor máximo encontrado em todo o array $dp$}.
+
+$$ \max_{0 \leq i < n} (dp[i])$$
+
+\subsection*{Complexidade}
+
+\begin{itemize}
+    \item \textbf{Tempo:} $O(n)$, pois percorremos a sequência de entrada uma única vez para preencher o array $dp$. Encontrar o máximo do array $dp$ também leva $O(n)$, o que pode ser feito simultaneamente.
+    \item \textbf{Espaço:} $O(n)$ para armazenar o array $dp$.
+\end{itemize}
+
+\textbf{Otimização de Espaço:} Note que o cálculo de $dp[i]$ depende apenas de $dp[i-1]$. Podemos otimizar o espaço para $O(1)$ mantendo apenas duas variáveis: uma para a "soma máxima terminando aqui" (equivalente a $dp[i-1]$) e outra para a "soma máxima global" (a resposta final).\end{document}
diff --git a/maximum-subarray-sum/maximum-subarray-sum.pdf b/maximum-subarray-sum/maximum-subarray-sum.pdf
index e098129..3af032c 100644
Binary files a/maximum-subarray-sum/maximum-subarray-sum.pdf and b/maximum-subarray-sum/maximum-subarray-sum.pdf differ
diff --git a/maximum-subarray-sum/statement/tutorial.tex b/maximum-subarray-sum/statement/tutorial.tex
index e69de29..4aec35f 100644
--- a/maximum-subarray-sum/statement/tutorial.tex
+++ b/maximum-subarray-sum/statement/tutorial.tex
@@ -0,0 +1,47 @@
+O problema pode ser resolvido eficientemente utilizando uma abordagem de \textbf{programação dinâmica}, comumente conhecida como \textbf{Algoritmo de Kadane}. A ideia central é calcular, para cada posição $i$ da sequência, a maior soma de uma subsequência contínua que termina exatamente naquela posição.
+
+\subsection*{Modelagem}
+
+Dada uma sequência de entrada $A$ de tamanho $n$ (com índices de $0$ a $n-1$), queremos encontrar a maior soma possível $\sum_{k=i}^{j} A[k]$ para quaisquer índices $0 \leq i \leq j < n$.
+
+O algoritmo de Kadane resolve isso de forma linear, mantendo o controle da melhor subsequência encontrada até o momento.
+
+\subsection*{Definição da DP}
+
+Definimos $dp[i]$ como o valor da \textbf{maior soma de uma subsequência contínua que termina no índice $i$}.
+
+\subsection*{Função de Transição}
+
+Para calcular o valor de $dp[i]$, temos duas escolhas:
+
+A subsequência máxima que termina em $i$ é formada \textbf{apenas pelo elemento $A[i]$}. Isso ocorre se a soma da subsequência anterior ($dp[i-1]$) for negativa, pois estendê-la apenas diminuiria o valor.
+
+A subsequência máxima que termina em $i$ é uma \textbf{extensão da subsequência máxima que terminava em $i-1$}, adicionando $A[i]$. A soma seria $dp[i-1] + A[i]$.
+
+Selecionamos a maior dessas duas opções. Portanto, a função de transição é:
+
+$$dp[i] = \max(A[i], \quad dp[i-1] + A[i])$$
+
+\subsection*{Casos Base}
+
+A primeira subsequência possível (que termina no índice $0$) deve obrigatoriamente conter $A[0]$.
+O caso base é:
+
+$$dp[0] = A[0]$$
+
+\subsection*{Resposta Final}
+
+É importante notar que $dp[n-1]$ é apenas a maior soma terminando na última posição, o que não é necessariamente a resposta final do problema.
+
+A subsequência de soma máxima pode terminar em qualquer índice $i$. Portanto, a resposta final é o \textbf{valor máximo encontrado em todo o array $dp$}.
+
+$$ \max_{0 \leq i < n} (dp[i])$$
+
+\subsection*{Complexidade}
+
+\begin{itemize}
+    \item \textbf{Tempo:} $O(n)$, pois percorremos a sequência de entrada uma única vez para preencher o array $dp$. Encontrar o máximo do array $dp$ também leva $O(n)$, o que pode ser feito simultaneamente.
+    \item \textbf{Espaço:} $O(n)$ para armazenar o array $dp$.
+\end{itemize}
+
+\textbf{Otimização de Espaço:} Note que o cálculo de $dp[i]$ depende apenas de $dp[i-1]$. Podemos otimizar o espaço para $O(1)$ mantendo apenas duas variáveis: uma para a "soma máxima terminando aqui" (equivalente a $dp[i-1]$) e outra para a "soma máxima global" (a resposta final).
\ No newline at end of file